16 files changed, 2622 insertions, 0 deletions
diff --git a/MdePkg/Include/Dxe/ArchProtocol/Bds.h b/MdePkg/Include/Dxe/ArchProtocol/Bds.h
new file mode 100644
index 0000000000..f6b72d2b00
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Bds.h
@@ -0,0 +1,87 @@
+/** @file
+  Boot Device Selection Architectural Protocol as defined in DXE CIS
+
+  When the DXE core is done it calls the BDS via this protocol.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Bds.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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
+  );
+
+/**
+  Interface stucture for the BDS Architectural Protocol.
+
+  @par Protocol Description:
+  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.
+
+  @par Protocol Parameters:
+  Entry - The entry point to BDS.  This call does not take any parameters, 
+  and the return value can be ignored.  If it returns, then the 
+  dispatcher must be invoked again, if it never returns, then an 
+  operating system or a system utility have been invoked.
+
+**/
+struct _EFI_BDS_ARCH_PROTOCOL {
+  EFI_BDS_ENTRY Entry;
+};
+
+extern EFI_GUID gEfiBdsArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Dxe/ArchProtocol/Cpu.h b/MdePkg/Include/Dxe/ArchProtocol/Cpu.h
new file mode 100644
index 0000000000..975a816356
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Cpu.h
@@ -0,0 +1,326 @@
+/** @file
+  CPU Architectural Protocol as defined in DXE CIS
+
+  This code abstracts the DXE core from processor implementation details.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Cpu.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#ifndef __ARCH_PROTOCOL_CPU_H__
+#define __ARCH_PROTOCOL_CPU_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;
+
+typedef enum {
+  EfiCpuFlushTypeWriteBackInvalidate,
+  EfiCpuFlushTypeWriteBack,
+  EfiCpuFlushTypeInvalidate,
+  EfiCpuMaxFlushType
+} EFI_CPU_FLUSH_TYPE;
+
+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
+(*EFI_CPU_INTERRUPT_HANDLER) (
+  IN EFI_EXCEPTION_TYPE                 InterruptType,
+  IN 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_UNSUPPORTEDT 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.
+
+  @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.
+  @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
+  );
+
+
+/**
+  @par Protocol Description:
+  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.
+
+  @param FlushDataCache
+  Flushes a range of the processor's data cache. If the processor does 
+  not contain a data cache, or the data cache is fully coherent, then this 
+  function can just return EFI_SUCCESS. If the processor does not support 
+  flushing a range of addresses from the data cache, then the entire data 
+  cache must be flushed. 
+
+  @param EnableInterrupt    Enables interrupt processing by the processor. 
+
+  @param DisableInterrupt    Disables interrupt processing by the processor.
+
+  @param GetInterruptState  Retrieves the processor's current interrupt state.
+
+  @param Init
+  Generates an INIT on the processor. If a processor cannot programmatically 
+  generate an INIT without help from external hardware, then this function 
+  returns EFI_UNSUPPORTED.
+
+  @param RegisterInterruptHandler
+  Associates an interrupt service routine with one of the processor's interrupt 
+  vectors. This function is typically used by the EFI_TIMER_ARCH_PROTOCOL to 
+  hook the timer interrupt in a system. It can also be used by the debugger to 
+  hook exception vectors.
+
+  @param GetTimerValue    Returns the value of one of the processor's internal timers.
+
+  @param SetMemoryAttributes  Attempts to set the attributes of a memory region.
+
+  @param NumberOfTimers
+  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.
+
+  @param DmaBufferAlignment
+  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.
+
+**/
+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;
+  UINT32                              NumberOfTimers;
+  UINT32                              DmaBufferAlignment;
+};
+
+extern EFI_GUID gEfiCpuArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Dxe/ArchProtocol/Metronome.h b/MdePkg/Include/Dxe/ArchProtocol/Metronome.h
new file mode 100644
index 0000000000..a07003e5cc
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Metronome.h
@@ -0,0 +1,100 @@
+/** @file
+  Metronome Architectural Protocol as defined in DXE CIS
+
+  This code abstracts the DXE core to provide delay services.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Metronome.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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
+  );
+
+//
+//
+
+/**
+  Interface stucture for the Metronome Architectural Protocol.
+
+  @par Protocol Description:
+  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.  
+
+  @param WaitForTick
+  Waits for a specified number of ticks from a known time source 
+  in the platform.  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.
+
+  @param TickPeriod
+  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.
+
+**/
+struct _EFI_METRONOME_ARCH_PROTOCOL {
+  EFI_METRONOME_WAIT_FOR_TICK  WaitForTick;
+  UINT32                       TickPeriod;
+};
+
+extern EFI_GUID gEfiMetronomeArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Dxe/ArchProtocol/MonotonicCounter.h b/MdePkg/Include/Dxe/ArchProtocol/MonotonicCounter.h
new file mode 100644
index 0000000000..d25374074d
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/MonotonicCounter.h
@@ -0,0 +1,33 @@
+/** @file
+  Monotonic Counter Architectural Protocol as defined in DXE CIS
+
+  This code provides the services required to access the systems monotonic counter
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  MonotonicCounter.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#ifndef __ARCH_PROTOCOL_MONTONIC_COUNTER_H__
+#define __ARCH_PROTOCOL_MONTONIC_COUNTER_H__
+
+///
+/// Global ID for the Monotonic Counter Architectural Protocol
+///
+#define EFI_MONTONIC_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/Dxe/ArchProtocol/RealTimeClock.h b/MdePkg/Include/Dxe/ArchProtocol/RealTimeClock.h
new file mode 100644
index 0000000000..dc968e1666
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/RealTimeClock.h
@@ -0,0 +1,41 @@
+/** @file
+  Real Time clock Architectural Protocol as defined in DXE CIS
+
+  This code abstracts time and data functions. Used to provide
+  Time and date related EFI runtime services.
+
+  The GetTime (), SetTime (), GetWakeupTime (), and SetWakeupTime () EFI 1.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, as it is done in the DXE core.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  RealTimeClock.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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/Dxe/ArchProtocol/Reset.h b/MdePkg/Include/Dxe/ArchProtocol/Reset.h
new file mode 100644
index 0000000000..80befae95f
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Reset.h
@@ -0,0 +1,38 @@
+/** @file
+  Reset Architectural Protocol as defined in the DXE CIS
+
+  Used to provide ResetSystem runtime services
+
+  The ResetSystem () EFI 1.0 service is added to the EFI system table and the 
+  EFI_RESET_ARCH_PROTOCOL_GUID protocol is registered with a NULL pointer.
+
+  No CRC of the EFI system table is required, as it is done in the DXE core.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Reset.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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/Dxe/ArchProtocol/Runtime.h b/MdePkg/Include/Dxe/ArchProtocol/Runtime.h
new file mode 100644
index 0000000000..bbd4c1a699
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Runtime.h
@@ -0,0 +1,162 @@
+/** @file
+  Runtime Architectural Protocol as defined in DXE CIS
+
+  This code is used to produce the EFI 1.0 runtime virtual switch over
+
+  This driver must add SetVirtualAddressMap () and ConvertPointer () to
+  the EFI system table. This driver is not responcible for CRCing the 
+  EFI system table.
+
+  This driver will add EFI_RUNTIME_ARCH_PROTOCOL_GUID protocol with a 
+  pointer to the Runtime Arch Protocol instance structure. The protocol
+  member functions are used by the DXE core to export information need
+  by this driver to produce the runtime transition to virtual mode
+  calling.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Runtime.h
+
+  @par Revision Reference:
+  Version 0.90.
+
+**/
+
+#ifndef __ARCH_PROTOCOL_RUNTIME_H__
+#define __ARCH_PROTOCOL_RUNTIME_H__
+
+//
+// Global ID for the Runtime Architectural Protocol
+//
+#define EFI_RUNTIME_ARCH_PROTOCOL_GUID \
+  { 0x96d08253, 0x8483, 0x11d4, {0xbc, 0xf1, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } }
+
+typedef struct _EFI_RUNTIME_ARCH_PROTOCOL   EFI_RUNTIME_ARCH_PROTOCOL;
+
+/**
+  When a SetVirtualAddressMap() is performed all the runtime images loaded by 
+  DXE must be fixed up with the new virtual address map. To facilitate this the 
+  Runtime Architectural Protocol needs to be informed of every runtime driver 
+  that is registered.  All the runtime images loaded by DXE should be registered 
+  with this service by the DXE Core when ExitBootServices() is called.  The 
+  images that are registered with this service must have successfully been 
+  loaded into memory with the Boot Service LoadImage().  As a result, no 
+  parameter checking needs to be performed.
+
+  @param  This The EFI_RUNTIME_ARCH_PROTOCOL instance.
+  
+  @param  ImageBase Start of image that has been loaded in memory. It is either
+  a pointer to the DOS or PE header of the image.
+  
+  @param  ImageSize Size of the image in bytes.
+  
+  @param  RelocationData Information about the fixups that were performed on ImageBase
+  when it was loaded into memory. This information is needed
+  when the virtual mode fix-ups are reapplied so that data that
+  has been programmatically updated will not be fixed up. If
+  code updates a global variable the code is responsible for
+  fixing up the variable for virtual mode.
+
+  @retval  EFI_SUCCESS The ImageBase has been registered.
+  
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources to register ImageBase.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RUNTIME_REGISTER_IMAGE) (
+  IN EFI_RUNTIME_ARCH_PROTOCOL  *This,
+  IN  EFI_PHYSICAL_ADDRESS              ImageBase,   
+  IN  UINTN                             ImageSize,     
+  IN  VOID                              *RelocationData    
+  );
+
+
+/**
+  This function is used to support the required runtime events. Currently only 
+  runtime events of type EFI_EVENT_SIGNAL_VIRTUAL_ADDRESS_CHANGE needs to be 
+  registered with this service.  All the runtime events that exist in the DXE 
+  Core should be registered with this service when ExitBootServices() is called.  
+  All the events that are registered with this service must have been created 
+  with the Boot Service CreateEvent().  As a result, no parameter checking needs 
+  to be performed.
+
+  @param  This The EFI_RUNTIME_ARCH_PROTOCOL instance.
+  
+  @param  Type The same as Type passed into CreateEvent().
+  
+  @param  NotifyTpl The same as NotifyTpl passed into CreateEvent().
+  
+  @param  NotifyFunction The same as NotifyFunction passed into CreateEvent().
+  
+  @param  NotifyContext The same as NotifyContext passed into CreateEvent().
+  
+  @param  Event The EFI_EVENT returned by CreateEvent().  Event must be in
+  runtime memory.
+
+  @retval  EFI_SUCCESS The Event has been registered.
+  
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources to register Event.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RUNTIME_REGISTER_EVENT) (
+  IN EFI_RUNTIME_ARCH_PROTOCOL  *This,
+  IN UINT32                             Type,
+  IN EFI_TPL                            NotifyTpl,
+  IN EFI_EVENT_NOTIFY                   NotifyFunction,
+  IN VOID                               *NotifyContext,
+  IN EFI_EVENT                          *Event
+  );
+
+//
+// Interface stucture for the Runtime Architectural Protocol
+//
+/**
+  @par Protocol Description:
+  The DXE driver that produces this protocol must be a runtime driver.  This 
+  driver is responsible for initializing the SetVirtualAddressMap() and 
+  ConvertPointer() fields of the EFI Runtime Services Table and the 
+  CalculateCrc32() field of the EFI Boot Services Table.  See the Runtime 
+  Services chapter and the Boot Services chapter for details on these services.
+  After the two fields of the EFI Runtime Services Table and the one field of 
+  the EFI Boot Services Table have been initialized, the driver must install 
+  the EFI_RUNTIME_ARCH_PROTOCOL_GUID on a new handle with an EFI_RUNTIME_ARCH_ 
+  PROTOCOL interface pointer.  The installation of this protocol informs the 
+  DXE core that the virtual memory services and the 32-bit CRC services are 
+  now available, and the DXE core must update the 32-bit CRC of the EFI Runtime 
+  Services Table and the 32-bit CRC of the EFI Boot Services Table.
+
+  All runtime core services are provided by the EFI_RUNTIME_ARCH_PROTOCOL.  
+  This includes the support for registering runtime images that must be 
+  re-fixed up when a transition is made from physical mode to virtual mode. 
+  This protocol also supports all events that are defined to fire at runtime. 
+  This protocol also contains a CRC-32 function that will be used by the DXE 
+  core as a boot service. The EFI_RUNTIME_ARCH_PROTOCOL needs the CRC-32 
+  function when a transition is made from physical mode to virtual mode and 
+  the EFI System Table and EFI Runtime Table are fixed up with virtual pointers.
+
+  @param RegisterRuntimeImage
+  Register a runtime image so it can be converted to virtual mode if the EFI Runtime Services 
+  SetVirtualAddressMap() is called.
+
+  @param RegisterRuntimeEvent
+  Register an event than needs to be notified at runtime. 
+
+**/
+struct _EFI_RUNTIME_ARCH_PROTOCOL {
+  EFI_RUNTIME_REGISTER_IMAGE  RegisterImage;
+  EFI_RUNTIME_REGISTER_EVENT  RegisterEvent;
+};
+
+extern EFI_GUID gEfiRuntimeArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Dxe/ArchProtocol/Security.h b/MdePkg/Include/Dxe/ArchProtocol/Security.h
new file mode 100644
index 0000000000..3598199b84
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Security.h
@@ -0,0 +1,136 @@
+/** @file
+  Security Architectural Protocol as defined in the DXE CIS
+
+  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, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Security.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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 EFI_SECURITY_ARCH_PROTOCOL     *This,
+  IN  UINT32                        AuthenticationStatus,
+  IN  EFI_DEVICE_PATH_PROTOCOL      *File
+  )
+;
+
+//
+// Interface stucture for the Timer Architectural Protocol
+//
+/**
+  @par Protocol Description:
+
+  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.
+
+  The driver that produces the EFI_SECURITY_ARCH_PROTOCOL may also optionally 
+  install the EFI_SECURITY_POLICY_PROTOCOL_GUID onto a new handle with a NULL 
+  interface.  The existence of this GUID in the protocol database means that 
+  the GUIDed Section Extraction Protocol should authenticate the contents of 
+  an Authentication Section.  The expectation is that the GUIDed Section 
+  Extraction protocol will look for the existence of the EFI_SECURITY_POLICY_ 
+  PROTOCOL_GUID in the protocol database.  If it exists, then the publication 
+  thereof is taken as an injunction to attempt an authentication of any section 
+  wrapped in an Authentication Section.  See the Firmware File System 
+  Specification for details on the GUIDed Section Extraction Protocol and 
+  Authentication Sections.
+
+  @par Protocol Parameters:
+
+  FileAuthenticationState - This service is called upon fault with respect to 
+  the authentication of a section of a file.
+
+**/
+struct _EFI_SECURITY_ARCH_PROTOCOL {
+  EFI_SECURITY_FILE_AUTHENTICATION_STATE  FileAuthenticationState;
+};
+
+extern EFI_GUID gEfiSecurityArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Dxe/ArchProtocol/SecurityPolicy.h b/MdePkg/Include/Dxe/ArchProtocol/SecurityPolicy.h
new file mode 100644
index 0000000000..b46267e10a
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/SecurityPolicy.h
@@ -0,0 +1,31 @@
+/** @file
+  Security Policy protocol as defined in the DXE CIS
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  SecurityPolicy.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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/Dxe/ArchProtocol/StatusCode.h b/MdePkg/Include/Dxe/ArchProtocol/StatusCode.h
new file mode 100644
index 0000000000..6440dc3388
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/StatusCode.h
@@ -0,0 +1,82 @@
+/** @file
+  Status code Runtime Protocol as defined in the DXE CIS
+
+  The StatusCode () Tiano service is added to the EFI system table and the 
+  EFI_STATUS_CODE_ARCH_PROTOCOL_GUID protocol is registered with a NULL 
+  pointer.
+
+  No CRC of the EFI system table is required, as it is done in the DXE core.
+
+  This code abstracts Status Code reporting.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  StatusCode.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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
+  );
+
+/**
+  @par Protocol Description:
+  Provides the service required to report a status code to the platform firmware.
+  This protocol must be produced by a runtime DXE driver and may be consumed 
+  only by the DXE Foundation.
+
+  @param ReportStatusCode Emit a status code.
+
+**/
+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/Dxe/ArchProtocol/Timer.h b/MdePkg/Include/Dxe/ArchProtocol/Timer.h
new file mode 100644
index 0000000000..330f4cfd68
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Timer.h
@@ -0,0 +1,222 @@
+/** @file
+  Timer Architectural Protocol as defined in the DXE CIS
+
+  This code is used to provide the timer tick for the DXE core.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Timer.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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 funtion
+  of tyis 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_UNSUPPORTEDT 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
+  );
+
+
+/**
+  Interface stucture for the Timer Architectural Protocol.
+
+  @par Protocol Description:
+  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.
+
+  @param RegisterHandler
+  Registers a handler that will be called each time the 
+  timer interrupt fires.  TimerPeriod defines the minimum 
+  time between timer interrupts, so TimerPeriod will also 
+  be the minimum time between calls to the registered 
+  handler.
+
+  @param SetTimerPeriod
+  Sets the period of the timer interrupt in 100 nS units.  
+  This function is optional, and may return EFI_UNSUPPORTED.  
+  If this function is supported, then the timer period will 
+  be rounded up to the nearest supported timer period.
+
+  @param GetTimerPeriod
+  Retrieves the period of the timer interrupt in 100 nS units.
+
+  @param GenerateSoftInterrupt
+  Generates a soft timer interrupt that simulates the firing of 
+  the timer interrupt. This service can be used to invoke the 
+  registered handler if the timer interrupt has been masked for 
+  a period of time.
+
+**/
+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/Dxe/ArchProtocol/Variable.h b/MdePkg/Include/Dxe/ArchProtocol/Variable.h
new file mode 100644
index 0000000000..13eb113bcc
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/Variable.h
@@ -0,0 +1,39 @@
+/** @file
+  Variable Architectural Protocol as defined in the DXE CIS
+
+  This code is used to produce the EFI 1.0 runtime variable services
+
+  The GetVariable (), GetNextVariableName (), and SetVariable () EFI 1.0 
+  services are added to the EFI system table and the 
+  EFI_VARIABLE_ARCH_PROTOCOL_GUID protocol is registered with a NULL pointer.
+
+  No CRC of the EFI system table is required, as it is done in the DXE core.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  Variable.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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/Dxe/ArchProtocol/VariableWrite.h b/MdePkg/Include/Dxe/ArchProtocol/VariableWrite.h
new file mode 100644
index 0000000000..8c21df54f1
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/VariableWrite.h
@@ -0,0 +1,38 @@
+/** @file
+  Variable Write Architectural Protocol as defined in the DXE CIS
+
+  This code is used to produce the EFI 1.0 runtime variable services
+
+  The SetVariable () EFI 1.0 services may be updated to the EFI system table and the 
+  EFI_VARIABLE_WRITE_ARCH_PROTOCOL_GUID protocol is registered with a NULL pointer.
+
+  No CRC of the EFI system table is required, as it is done in the DXE core.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  VariableWrite.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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/Dxe/ArchProtocol/WatchdogTimer.h b/MdePkg/Include/Dxe/ArchProtocol/WatchdogTimer.h
new file mode 100644
index 0000000000..a8d84b18da
--- /dev/null
+++ b/MdePkg/Include/Dxe/ArchProtocol/WatchdogTimer.h
@@ -0,0 +1,172 @@
+/** @file
+  Watchdog Timer Architectural Protocol as defined in the DXE CIS
+
+  Used to provide system watchdog timer services
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  WatchdogTimer.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#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
+  );
+
+
+/**
+  Interface stucture for the Watchdog Timer Architectural Protocol.
+
+  @par Protocol Description:
+  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().
+
+  @param RegisterHandler - Registers a handler that is invoked when the watchdog 
+  timer fires.
+
+  @param SetTimerPeriod  - Sets the amount of time in 100 ns units to wait before the 
+  watchdog timer is fired.  If this function is supported, 
+  then the watchdog timer period will be rounded up to the 
+  nearest supported watchdog timer period.
+
+  @param GetTimerPeriod  - Retrieves the amount of time in 100 ns units that the 
+  system will wait before the watchdog timer is fired.
+
+**/
+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/Dxe/DxeCis.h b/MdePkg/Include/Dxe/DxeCis.h
new file mode 100644
index 0000000000..a36481c817
--- /dev/null
+++ b/MdePkg/Include/Dxe/DxeCis.h
@@ -0,0 +1,589 @@
+/** @file
+  Include file matches things in the DXE CIS.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  DxeCis.h
+
+  @par Revision Reference:
+  Version 0.91B.
+
+**/
+
+#ifndef __DXE_CIS__
+#define __DXE_CIS__
+
+#include <Uefi/UefiSpec.h>
+
+
+#define TIANO_ERROR(a)              (MAX_2_BITS | (a))
+
+#if (EFI_SPECIFICATION_VERSION < 0x00020000)
+//
+// Tiano added a couple of return types. These are owned by UEFI specification
+//  and Tiano can not use them. Thus for UEFI 2.0/R9 support we moved the values
+//  to a UEFI OEM extension range to conform to UEFI specification.
+//
+#define EFI_NOT_AVAILABLE_YET   EFIERR (28)
+#define EFI_UNLOAD_IMAGE        EFIERR (29)
+#else
+#define EFI_NOT_AVAILABLE_YET   TIANO_ERROR (0)
+#define EFI_UNLOAD_IMAGE        TIANO_ERROR (1)
+#endif
+
+//
+// BugBug: Implementation contamination of UEFI 2.0
+// Pointer to internal runtime pointer
+//
+#define EFI_IPF_GP_POINTER  0x00000008
+
+
+//
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+
+//
+// attributes for reserved memory before it is promoted to system memory
+//
+#define EFI_MEMORY_PRESENT      0x0100000000000000ULL
+#define EFI_MEMORY_INITIALIZED  0x0200000000000000ULL
+#define EFI_MEMORY_TESTED       0x0400000000000000ULL
+
+//
+// range for memory mapped port I/O on IPF
+//
+#define EFI_MEMORY_PORT_IO  0x4000000000000000ULL
+
+//
+// Modifier for EFI DXE Services
+//
+#define EFI_DXESERVICE
+
+
+//
+// Global Coherencey Domain types
+//
+typedef enum {
+  EfiGcdMemoryTypeNonExistent,
+  EfiGcdMemoryTypeReserved,
+  EfiGcdMemoryTypeSystemMemory,
+  EfiGcdMemoryTypeMemoryMappedIo,
+  EfiGcdMemoryTypeMaximum
+} EFI_GCD_MEMORY_TYPE;
+
+typedef enum {
+  EfiGcdIoTypeNonExistent,
+  EfiGcdIoTypeReserved,
+  EfiGcdIoTypeIo,
+  EfiGcdIoTypeMaximum
+} EFI_GCD_IO_TYPE;
+
+typedef enum {
+  EfiGcdAllocateAnySearchBottomUp,
+  EfiGcdAllocateMaxAddressSearchBottomUp,
+  EfiGcdAllocateAddress,
+  EfiGcdAllocateAnySearchTopDown,
+  EfiGcdAllocateMaxAddressSearchTopDown,
+  EfiGcdMaxAllocateType
+} EFI_GCD_ALLOCATE_TYPE;
+
+typedef struct {
+  EFI_PHYSICAL_ADDRESS  BaseAddress;
+  UINT64                Length;
+  UINT64                Capabilities;
+  UINT64                Attributes;
+  EFI_GCD_MEMORY_TYPE   GcdMemoryType;
+  EFI_HANDLE            ImageHandle;
+  EFI_HANDLE            DeviceHandle;
+} EFI_GCD_MEMORY_SPACE_DESCRIPTOR;
+
+typedef struct {
+  EFI_PHYSICAL_ADDRESS  BaseAddress;
+  UINT64                Length;
+  EFI_GCD_IO_TYPE       GcdIoType;
+  EFI_HANDLE            ImageHandle;
+  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 Memory type of the memory space.
+  
+  @param  BaseAddress Base address of the memory space.
+  
+  @param  Length Length of the memory space.
+  
+  @param  Capabilities alterable attributes of the memory space.
+
+  @retval  EFI_SUCCESS Merged this memory space into GCD map.
+
+**/
+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 allocate operation
+  
+  @param  GcdMemoryType The desired memory type
+  
+  @param  Alignment Align with 2^Alignment
+  
+  @param  Length Length to allocate
+  
+  @param  BaseAddress Base address to allocate
+  
+  @param  Imagehandle The image handle consume the allocated space.
+  
+  @param  DeviceHandle The device handle consume the allocated space.
+
+  @retval  EFI_INVALID_PARAMETER Invalid parameter.
+  
+  @retval  EFI_NOT_FOUND No descriptor contains the desired space.
+  
+  @retval  EFI_SUCCESS Memory space successfully allocated.
+
+**/
+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 Base address of the segment.
+  
+  @param  Length Length of the segment.
+
+  @retval  EFI_SUCCESS Space successfully freed.
+
+**/
+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 Base address of the memory space.
+  
+  @param  Length Length of the memory space.
+
+  @retval  EFI_SUCCESS Successfully remove a segment of memory space.
+
+**/
+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 Specified start address
+  
+  @param  Descriptor Specified length
+
+  @retval  EFI_INVALID_PARAMETER Invalid parameter
+  
+  @retval  EFI_SUCCESS Successfully get memory space descriptor.
+
+**/
+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 Specified start address
+  
+  @param  Length Specified length
+  
+  @param  Attributes Specified attributes
+
+  @retval  EFI_SUCCESS Successfully set attribute of a segment of memory space.
+
+**/
+typedef
+
+EFI_STATUS
+(EFIAPI *EFI_SET_MEMORY_SPACE_ATTRIBUTES) (
+  IN EFI_PHYSICAL_ADDRESS         BaseAddress,
+  IN UINT64                       Length,
+  IN UINT64                       Attributes
+  )
+;
+
+/**
+  Returns a map of the memory resources in the global coherency domain of the
+  processor.
+
+  @param  NumberOfDescriptors Number of descriptors.
+  
+  @param  MemorySpaceMap Descriptor array
+
+  @retval  EFI_INVALID_PARAMETER Invalid parameter
+  
+  @retval  EFI_OUT_OF_RESOURCES No enough buffer to allocate
+  
+  @retval  EFI_SUCCESS Successfully get memory space map.
+
+**/
+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 IO type of the segment.
+  
+  @param  BaseAddress Base address of the segment.
+  
+  @param  Length Length of the segment.
+
+  @retval  EFI_SUCCESS Merged this segment into GCD map.
+
+**/
+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 allocate operation
+  
+  @param  GcdIoType The desired IO type
+  
+  @param  Alignment Align with 2^Alignment
+  
+  @param  Length Length to allocate
+  
+  @param  BaseAddress Base address to allocate
+  
+  @param  Imagehandle The image handle consume the allocated space.
+  
+  @param  DeviceHandle The device handle consume the allocated space.
+
+  @retval  EFI_INVALID_PARAMETER Invalid parameter.
+  
+  @retval  EFI_NOT_FOUND No descriptor contains the desired space.
+  
+  @retval  EFI_SUCCESS IO space successfully allocated.
+
+**/
+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 Base address of the segment.
+  
+  @param  Length Length of the segment.
+
+  @retval  EFI_SUCCESS Space successfully freed.
+
+**/
+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 Base address of the segment.
+  
+  @param  Length Length of the segment.
+
+  @retval  EFI_SUCCESS Successfully removed a segment of IO space.
+
+**/
+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 Specified start address
+  
+  @param  Descriptor Specified length
+
+  @retval  EFI_INVALID_PARAMETER Descriptor is NULL.
+  
+  @retval  EFI_SUCCESS Successfully get the IO space descriptor.
+
+**/
+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 Number of descriptors.
+  
+  @param  MemorySpaceMap Descriptor array
+
+  @retval  EFI_INVALID_PARAMETER Invalid parameter
+  
+  @retval  EFI_OUT_OF_RESOURCES No enough buffer to allocate
+  
+  @retval  EFI_SUCCESS Successfully get IO space map.
+
+**/
+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.
+
+  @return Status code
+
+**/
+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  DriverName A pointer to the name of the file in a firmware volume.
+
+  @return Status code
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCHEDULE) (
+  IN EFI_HANDLE  FirmwareVolumeHandle,
+  IN EFI_GUID    *DriverName
+  )
+;
+
+/**
+  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 code
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TRUST) (
+  IN EFI_HANDLE  FirmwareVolumeHandle,
+  IN EFI_GUID    *DriverName
+  )
+;
+
+/**
+  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.
+
+  @return Status code
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PROCESS_FIRMWARE_VOLUME) (
+  IN VOID                             *FvHeader,
+  IN UINTN                            Size,
+  OUT EFI_HANDLE                      *FirmwareVolumeHandle
+  )
+;
+
+//
+// DXE Services Table
+//
+#define EFI_DXE_SERVICES_SIGNATURE  0x565245535f455844ULL
+#define EFI_DXE_SERVICES_REVISION   ((0 << 16) | (25))
+
+typedef struct {
+  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;
+} EFI_DXE_SERVICES;
+
+
+#include <Common/BootMode.h>
+#include <Common/BootScript.h>
+#include <Common/Capsule.h>
+#include <Common/Dependency.h>
+#include <Common/FirmwareVolumeImageFormat.h>
+#include <Common/FirmwareVolumeHeader.h>
+#include <Common/FirmwareFileSystem.h>
+#include <Common/Hob.h>
+#include <Common/InternalFormRepresentation.h>
+#include <Common/StatusCode.h>
+#include <Common/StatusCodeDataTypeId.h>
+
+#include <Guid/AcpiTableStorage.h>
+#include <Guid/Apriori.h>
+#include <Guid/Capsule.h>
+#include <Guid/DxeServices.h>
+#include <Guid/EventLegacyBios.h>
+#include <Guid/FirmwareFileSystem.h>
+#include <Guid/FrameworkDevicePath.h>
+#include <Guid/HobList.h>
+#include <Guid/MemoryAllocationHob.h>
+#include <Guid/SmramMemoryReserve.h>
+#include <Guid/StatusCodeDataTypeId.h>
+
+#include <Dxe/ArchProtocol/Bds.h>
+#include <Dxe/ArchProtocol/Cpu.h>
+#include <Dxe/ArchProtocol/Metronome.h>
+#include <Dxe/ArchProtocol/MonotonicCounter.h>
+#include <Dxe/ArchProtocol/RealTimeClock.h>
+#include <Dxe/ArchProtocol/Reset.h>
+#include <Dxe/ArchProtocol/Runtime.h>
+#include <Dxe/ArchProtocol/Security.h>
+#include <Dxe/ArchProtocol/SecurityPolicy.h>
+#include <Dxe/ArchProtocol/StatusCode.h>
+#include <Dxe/ArchProtocol/Timer.h>
+#include <Dxe/ArchProtocol/Variable.h>
+#include <Dxe/ArchProtocol/VariableWrite.h>
+#include <Dxe/ArchProtocol/WatchdogTimer.h>
+
+#include <Protocol/AcpiSupport.h>
+#include <Protocol/BootScriptSave.h>
+#include <Protocol/CpuIo.h>
+#include <Protocol/DataHub.h>
+#include <Protocol/FirmwareVolume.h>
+#include <Protocol/FirmwareVolumeBlock.h>
+#include <Protocol/FirmwareVolumeDispatch.h>
+#include <Protocol/Hii.h>
+#include <Protocol/FormBrowser.h>
+#include <Protocol/FormCallback.h>
+#include <Protocol/GuidedSectionExtraction.h>
+#include <Protocol/IdeControllerInit.h>
+#include <Protocol/IncompatiblePciDeviceSupport.h>
+#include <Protocol/PciHostBridgeResourceAllocation.h>
+#include <Protocol/PciHotPlugInit.h>
+#include <Protocol/PciPlatform.h>
+#include <Protocol/SectionExtraction.h>
+#include <Protocol/Smbus.h>
+#include <Protocol/LegacyBios.h>
+#include <Protocol/Legacy8259.h>
+#include <Protocol/LegacyRegion.h>
+#include <Protocol/LegacyBiosPlatform.h>
+#include <Protocol/LegacyInterrupt.h>
+
+#endif
diff --git a/MdePkg/Include/Dxe/SmmCis.h b/MdePkg/Include/Dxe/SmmCis.h
new file mode 100644
index 0000000000..35a1a64682
--- /dev/null
+++ b/MdePkg/Include/Dxe/SmmCis.h
@@ -0,0 +1,526 @@
+/** @file
+  Include file matches things in the Smm CIS spec.
+
+  Copyright (c) 2006, Intel Corporation                                                         
+  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.             
+
+  Module Name:  SmmCis.h
+
+  @par Revision Reference:
+  Version 0.9.
+
+**/
+
+#ifndef __SMM_CIS__
+#define __SMM_CIS__
+
+#define EFI_SMM_CPU_IO_GUID \
+  { \
+    0x5f439a0b, 0x45d8, 0x4682, {0xa4, 0xf4, 0xf0, 0x57, 0x6b, 0x51, 0x34, 0x41 } \
+  }
+
+typedef struct _EFI_SMM_SYSTEM_TABLE              EFI_SMM_SYSTEM_TABLE;
+typedef struct _EFI_SMM_CPU_IO_INTERFACE          EFI_SMM_CPU_IO_INTERFACE;
+
+
+//
+// SMM Base specification constant and types
+//
+#define SMM_SMST_SIGNATURE            EFI_SIGNATURE_32 ('S', 'M', 'S', 'T')
+#define EFI_SMM_SYSTEM_TABLE_REVISION (0 << 16) | (0x09)
+
+//
+// *******************************************************
+// EFI_SMM_IO_WIDTH
+// *******************************************************
+//
+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 that are used to 
+  abstract accesses to devices.
+
+  @param  This The EFI_SMM_CPU_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 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_IO) (
+  IN EFI_SMM_CPU_IO_INTERFACE         *This,
+  IN EFI_SMM_IO_WIDTH                 Width,
+  IN UINT64                           Address,
+  IN UINTN                            Count,
+  IN OUT VOID                         *Buffer
+  );
+
+typedef struct {
+  EFI_SMM_CPU_IO  Read;
+  EFI_SMM_CPU_IO  Write;
+} EFI_SMM_IO_ACCESS;
+
+struct _EFI_SMM_CPU_IO_INTERFACE {
+  EFI_SMM_IO_ACCESS Mem;
+  EFI_SMM_IO_ACCESS Io;
+};
+
+/**
+  Allocates pool memory from SMRAM for IA-32 or runtime memory for 
+  the Itanium processor family.
+
+  @param  PoolType The type of pool to allocate.The only supported type is EfiRuntimeServicesData
+  
+  @param  Size The number of bytes to allocate from the pool.
+  
+  @param  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_UNSUPPORTED  In runtime.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMMCORE_ALLOCATE_POOL) (
+  IN EFI_MEMORY_TYPE                PoolType,
+  IN UINTN                          Size,
+  OUT VOID                          **Buffer
+  );
+
+/**
+  Returns pool memory to the system.
+
+  @param  Buffer Pointer to the buffer to free.
+
+  @retval EFI_SUCCESS  The memory was returned to the system.
+  
+  @retval EFI_INVALID_PARAMETER  Buffer was invalid.  
+  
+  @retval EFI_UNSUPPORTED  In runtime.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMMCORE_FREE_POOL) (
+  IN VOID                   *Buffer
+  );
+
+/**
+  Allocates memory pages from the system.
+
+  @param  Type The type of allocation to perform. 
+  
+  @param  MemoryType The only supported type is EfiRuntimeServicesData
+  
+  @param  NumberofPages The number of contiguous 4 KB pages to allocate
+  
+  @param  Memory Pointer to a physical address. On input, the way in which 
+  the address is used depends on the value of Type. On output, the address 
+  is set to the base of the page range that was allocated.
+
+  @retval EFI_SUCCESS  The requested pages were allocated.
+  
+  @retval EFI_OUT_OF_RESOURCES  The pages requested could not be allocated.
+  
+  @retval EFI_NOT_FOUND   The requested pages could not be found.
+  
+  @retval EFI_INVALID_PARAMETER  Type is not AllocateAnyPages or AllocateMaxAddress 
+  or AllocateAddress. Or MemoryType is in the range EfiMaxMemoryType..0x7FFFFFFF.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMMCORE_ALLOCATE_PAGES) (
+  IN EFI_ALLOCATE_TYPE      Type,
+  IN EFI_MEMORY_TYPE        MemoryType,
+  IN UINTN                  NumberOfPages,
+  OUT EFI_PHYSICAL_ADDRESS  *Memory
+  );
+
+/**
+  Frees memory pages for the system.
+
+  @param  Memory The base physical address of the pages to be freed
+  
+  @param  NumberOfPages The number of contiguous 4 KB pages to free.
+
+  @retval EFI_SUCCESS  The requested memory pages were freed.
+  
+  @retval EFI_INVALID_PARAMETER   Memory is not a page-aligned address or NumberOfPages is invalid.
+  
+  @retval EFI_NOT_FOUND   The requested memory pages were not allocated with SmmAllocatePages().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMMCORE_FREE_PAGES) (
+  IN EFI_PHYSICAL_ADDRESS   Memory,
+  IN UINTN                  NumberOfPages
+  );
+
+typedef
+VOID
+(EFIAPI *EFI_AP_PROCEDURE) (
+  IN  VOID                              *Buffer
+  );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_STARTUP_THIS_AP) (
+  IN  EFI_AP_PROCEDURE                    Procedure,
+  IN  UINTN                               CpuNumber,
+  IN  OUT VOID                            *ProcArguments OPTIONAL
+  );
+
+typedef struct {
+  UINT8                 Reserved1[248];
+  UINT32                SMBASE;
+  UINT32                SMMRevId;
+  UINT16                IORestart;
+  UINT16                AutoHALTRestart;
+  UINT8                 Reserved2[164];
+  UINT32                ES;
+  UINT32                CS;
+  UINT32                SS;
+  UINT32                DS;
+  UINT32                FS;
+  UINT32                GS;
+  UINT32                LDTBase;
+  UINT32                TR;
+  UINT32                DR7;
+  UINT32                DR6;
+  UINT32                EAX;
+  UINT32                ECX;
+  UINT32                EDX;
+  UINT32                EBX;
+  UINT32                ESP;
+  UINT32                EBP;
+  UINT32                ESI;
+  UINT32                EDI;
+  UINT32                EIP;
+  UINT32                EFLAGS;
+  UINT32                CR3;
+  UINT32                CR0;
+} EFI_SMI_CPU_SAVE_STATE;
+
+typedef struct {
+  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   pr;
+
+  UINT64   b0;
+  UINT64   b1;
+  UINT64   b2;
+  UINT64   b3;
+  UINT64   b4;
+  UINT64   b5;
+  UINT64   b6;
+  UINT64   b7;
+
+  // application registers
+  UINT64   ar_rsc;
+  UINT64   ar_bsp;
+  UINT64   ar_bspstore;
+  UINT64   ar_rnat;
+
+  UINT64   ar_fcr;
+
+  UINT64   ar_eflag;
+  UINT64   ar_csd;
+  UINT64   ar_ssd;
+  UINT64   ar_cflg;
+  UINT64   ar_fsr;
+  UINT64   ar_fir;
+  UINT64   ar_fdr;
+
+  UINT64   ar_ccv;
+
+  UINT64   ar_unat;
+
+  UINT64   ar_fpsr;
+
+  UINT64   ar_pfs;
+  UINT64   ar_lc;
+  UINT64   ar_ec;
+
+  // control registers
+  UINT64   cr_dcr;
+  UINT64   cr_itm;
+  UINT64   cr_iva;
+  UINT64   cr_pta;
+  UINT64   cr_ipsr;
+  UINT64   cr_isr;
+  UINT64   cr_iip;
+  UINT64   cr_ifa;
+  UINT64   cr_itir;
+  UINT64   cr_iipa;
+  UINT64   cr_ifs;
+  UINT64   cr_iim;
+  UINT64   cr_iha;
+
+  // 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
+  UINT64   int_nat;         // nat bits for R1-R31
+
+} EFI_PMI_SYSTEM_CONTEXT;
+
+typedef union {
+  EFI_SMI_CPU_SAVE_STATE     Ia32SaveState;
+  EFI_PMI_SYSTEM_CONTEXT     ItaniumSaveState;
+} EFI_SMM_CPU_SAVE_STATE;
+
+typedef struct {
+  UINT16                Fcw;
+  UINT16                Fsw;
+  UINT16                Ftw;
+  UINT16                Opcode;
+  UINT32                Eip;
+  UINT16                Cs;
+  UINT16                Rsvd1;
+  UINT32                DataOffset;
+  UINT16                Ds;
+  UINT8                 Rsvd2[10];
+  UINT8                 St0Mm0[10], Rsvd3[6];
+  UINT8                 St0Mm1[10], Rsvd4[6];
+  UINT8                 St0Mm2[10], Rsvd5[6];
+  UINT8                 St0Mm3[10], Rsvd6[6];
+  UINT8                 St0Mm4[10], Rsvd7[6];
+  UINT8                 St0Mm5[10], Rsvd8[6];
+  UINT8                 St0Mm6[10], Rsvd9[6];
+  UINT8                 St0Mm7[10], Rsvd10[6];
+  UINT8                 Rsvd11[22*16];
+} EFI_SMI_OPTIONAL_FPSAVE_STATE;
+
+typedef struct {
+  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];
+} EFI_PMI_OPTIONAL_FLOATING_POINT_CONTEXT;
+
+typedef union {
+  EFI_SMI_OPTIONAL_FPSAVE_STATE             Ia32FpSave;
+  EFI_PMI_OPTIONAL_FLOATING_POINT_CONTEXT   ItaniumFpSave;
+} EFI_SMM_FLOATING_POINT_SAVE_STATE;
+
+/**
+  This function is the main entry point for an SMM handler dispatch 
+  or communicate-based callback. 
+
+  @param  SmmImageHandle A unique value returned by the SMM infrastructure 
+  in response to registration for a communicate-based callback or dispatch. 
+  
+  @param  CommunicationBuffer An optional buffer that will be populated 
+  by the SMM infrastructure in response to a non-SMM agent (preboot or runtime) 
+  invoking the EFI_SMM_BASE_PROTOCOL.Communicate() service.
+  
+  @param  SourceSize If CommunicationBuffer is non-NULL, this field 
+  indicates the size of the data payload in this buffer.
+
+  @return Status Code
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT) (
+  IN EFI_HANDLE             SmmImageHandle,
+  IN OUT VOID               *CommunicationBuffer OPTIONAL,
+  IN OUT UINTN              *SourceSize OPTIONAL
+  );
+
+/**
+  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  SystemTable A pointer to the SMM System Table.
+  @param  Guid A pointer to the GUID for the entry to add, update, or remove.
+  @param  Table A pointer to the buffer of the table to add.
+  @param  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_TABLE) (
+  IN EFI_SMM_SYSTEM_TABLE         *SystemTable,
+  IN EFI_GUID                     *Guid,
+  IN VOID                         *Table,
+  IN UINTN                        TableSize
+  )
+;
+
+//
+// System Management System Table (SMST)
+//
+struct _EFI_SMM_SYSTEM_TABLE {
+  EFI_TABLE_HEADER                    Hdr;
+
+  CHAR16                              *SmmFirmwareVendor;
+  UINT32                              SmmFirmwareRevision;
+
+  EFI_SMM_INSTALL_CONFIGURATION_TABLE SmmInstallConfigurationTable;
+
+  //
+  // I/O Services
+  //
+  EFI_GUID                            EfiSmmCpuIoGuid;
+  EFI_SMM_CPU_IO_INTERFACE            SmmIo;
+
+  //
+  // Runtime memory service
+  //
+  EFI_SMMCORE_ALLOCATE_POOL           SmmAllocatePool;
+  EFI_SMMCORE_FREE_POOL               SmmFreePool;
+  EFI_SMMCORE_ALLOCATE_PAGES          SmmAllocatePages;
+  EFI_SMMCORE_FREE_PAGES              SmmFreePages;
+
+  //
+  // MP service
+  //
+  EFI_SMM_STARTUP_THIS_AP             SmmStartupThisAp;
+
+  //
+  // CPU information records
+  //
+  UINTN                               CurrentlyExecutingCpu;
+  UINTN                               NumberOfCpus;
+  EFI_SMM_CPU_SAVE_STATE              *CpuSaveState;
+  EFI_SMM_FLOATING_POINT_SAVE_STATE   *CpuOptionalFloatingPointState;
+
+  //
+  // Extensibility table
+  //
+  UINTN                               NumberOfTableEntries;
+  EFI_CONFIGURATION_TABLE             *SmmConfigurationTable;
+
+};
+
+#include <Guid/SmmCommunicate.h>
+#include <Guid/SmramMemoryReserve.h>
+#include <Protocol/SmmBase.h>
+#include <Protocol/SmmAccess.h>
+#include <Protocol/SmmControl.h>
+#include <Protocol/SmmGpiDispatch.h>
+#include <Protocol/SmmIchnDispatch.h>
+#include <Protocol/SmmPeriodicTimerDispatch.h>
+#include <Protocol/SmmPowerButtonDispatch.h>
+#include <Protocol/SmmStandbyButtonDispatch.h>
+#include <Protocol/SmmStatusCode.h>
+#include <Protocol/SmmSwDispatch.h>
+#include <Protocol/SmmSxDispatch.h>
+#include <Protocol/SmmUsbDispatch.h>
+
+extern EFI_GUID gEfiSmmCpuIoGuid;
+
+#endif