In PI 1.5 version, system management mode name(SMM) has been changed
to Management Mode(MM). It impacts the current code which still use
SMM/Smram/SMI keywords. This patch add new definition which use
MM/MmRam/MMI keywords to follow new spec definitions.
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Eric Dong <eric.dong@intel.com>
---
MdePkg/Include/Pi/PiMmCis.h | 350 +++++++++++++++++++++
MdePkg/Include/PiMm.h | 25 ++
MdePkg/Include/Protocol/DxeMmReadyToLock.h | 41 +++
MdePkg/Include/Protocol/MmAccess.h | 133 ++++++++
MdePkg/Include/Protocol/MmBase.h | 87 +++++
MdePkg/Include/Protocol/MmCommunication.h | 83 +++++
MdePkg/Include/Protocol/MmConfiguration.h | 86 +++++
MdePkg/Include/Protocol/MmControl.h | 106 +++++++
MdePkg/Include/Protocol/MmCpu.h | 247 +++++++++++++++
MdePkg/Include/Protocol/MmCpuIo.h | 96 ++++++
MdePkg/Include/Protocol/MmEndOfDxe.h | 33 ++
MdePkg/Include/Protocol/MmGpiDispatch.h | 125 ++++++++
MdePkg/Include/Protocol/MmIoTrapDispatch.h | 136 ++++++++
MdePkg/Include/Protocol/MmPciRootBridgeIo.h | 37 +++
MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h | 170 ++++++++++
MdePkg/Include/Protocol/MmPowerButtonDispatch.h | 117 +++++++
MdePkg/Include/Protocol/MmReadyToLock.h | 35 +++
.../Include/Protocol/MmReportStatusCodeHandler.h | 81 +++++
MdePkg/Include/Protocol/MmStandbyButtonDispatch.h | 119 +++++++
MdePkg/Include/Protocol/MmStatusCode.h | 65 ++++
MdePkg/Include/Protocol/MmSwDispatch.h | 136 ++++++++
MdePkg/Include/Protocol/MmSxDispatch.h | 135 ++++++++
MdePkg/Include/Protocol/MmUsbDispatch.h | 130 ++++++++
MdePkg/MdePkg.dec | 63 ++++
24 files changed, 2636 insertions(+)
create mode 100644 MdePkg/Include/Pi/PiMmCis.h
create mode 100644 MdePkg/Include/PiMm.h
create mode 100644 MdePkg/Include/Protocol/DxeMmReadyToLock.h
create mode 100644 MdePkg/Include/Protocol/MmAccess.h
create mode 100644 MdePkg/Include/Protocol/MmBase.h
create mode 100644 MdePkg/Include/Protocol/MmCommunication.h
create mode 100644 MdePkg/Include/Protocol/MmConfiguration.h
create mode 100644 MdePkg/Include/Protocol/MmControl.h
create mode 100644 MdePkg/Include/Protocol/MmCpu.h
create mode 100644 MdePkg/Include/Protocol/MmCpuIo.h
create mode 100644 MdePkg/Include/Protocol/MmEndOfDxe.h
create mode 100644 MdePkg/Include/Protocol/MmGpiDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmIoTrapDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmPciRootBridgeIo.h
create mode 100644 MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmPowerButtonDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmReadyToLock.h
create mode 100644 MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
create mode 100644 MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmStatusCode.h
create mode 100644 MdePkg/Include/Protocol/MmSwDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmSxDispatch.h
create mode 100644 MdePkg/Include/Protocol/MmUsbDispatch.h
diff --git a/MdePkg/Include/Pi/PiMmCis.h b/MdePkg/Include/Pi/PiMmCis.h
new file mode 100644
index 0000000..6f41fa9
--- /dev/null
+++ b/MdePkg/Include/Pi/PiMmCis.h
@@ -0,0 +1,350 @@
+/** @file
+ Common definitions in the Platform Initialization Specification version 1.6
+ VOLUME 4 Management Mode Core Interface version.
+
+ Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _PI_MMCIS_H_
+#define _PI_MMCIS_H_
+
+#include <Protocol/MmCpuIo.h>
+
+typedef struct _EFI_MM_SYSTEM_TABLE EFI_MM_SYSTEM_TABLE;
+
+///
+/// The Management Mode System Table (MMST) signature
+///
+#define MM_MMST_SIGNATURE SIGNATURE_32 ('S', 'M', 'S', 'T')
+///
+/// The Management Mode System Table (MMST) revision is 1.6
+///
+#define MM_SPECIFICATION_MAJOR_REVISION 1
+#define MM_SPECIFICATION_MINOR_REVISION 60
+#define EFI_MM_SYSTEM_TABLE_REVISION ((MM_SPECIFICATION_MAJOR_REVISION<<16) | (MM_SPECIFICATION_MINOR_REVISION))
+
+/**
+ Adds, updates, or removes a configuration table entry from the Management Mode System Table.
+
+ The MmInstallConfigurationTable() function is used to maintain the list
+ of configuration tables that are stored in the Management Mode System
+ Table. The list is stored as an array of (GUID, Pointer) pairs. The list
+ must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
+
+ @param[in] SystemTable A pointer to the MM System Table (MMST).
+ @param[in] Guid A pointer to the GUID for the entry to add, update, or remove.
+ @param[in] Table A pointer to the buffer of the table to add.
+ @param[in] TableSize The size of the table to install.
+
+ @retval EFI_SUCCESS The (Guid, Table) pair was added, updated, or removed.
+ @retval EFI_INVALID_PARAMETER Guid is not valid.
+ @retval EFI_NOT_FOUND An attempt was made to delete a non-existent entry.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory available to complete the operation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_INSTALL_CONFIGURATION_TABLE)(
+ IN CONST EFI_MM_SYSTEM_TABLE *SystemTable,
+ IN CONST EFI_GUID *Guid,
+ IN VOID *Table,
+ IN UINTN TableSize
+ );
+
+/**
+ This service lets the caller to get one distinct application processor (AP) to execute
+ a caller-provided code stream while in MM.
+
+ @param[in] Procedure A pointer to the code stream to be run on the designated
+ AP of the system.
+ @param[in] CpuNumber The zero-based index of the processor number of the AP
+ on which the code stream is supposed to run.
+ @param[in,out] ProcArguments Allows the caller to pass a list of parameters to the code
+ that is run by the AP.
+
+ @retval EFI_SUCCESS The call was successful and the return parameters are valid.
+ @retval EFI_INVALID_PARAMETER The input arguments are out of range.
+ @retval EFI_INVALID_PARAMETER The CPU requested is not available on this SMI invocation.
+ @retval EFI_INVALID_PARAMETER The CPU cannot support an additional service invocation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_STARTUP_THIS_AP)(
+ IN EFI_AP_PROCEDURE Procedure,
+ IN UINTN CpuNumber,
+ IN OUT VOID *ProcArguments OPTIONAL
+ );
+
+/**
+ Function prototype for protocol install notification.
+
+ @param[in] Protocol Points to the protocol's unique identifier.
+ @param[in] Interface Points to the interface instance.
+ @param[in] Handle The handle on which the interface was installed.
+
+ @return Status Code
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_NOTIFY_FN)(
+ IN CONST EFI_GUID *Protocol,
+ IN VOID *Interface,
+ IN EFI_HANDLE Handle
+ );
+
+/**
+ Register a callback function be called when a particular protocol interface is installed.
+
+ The MmRegisterProtocolNotify() function creates a registration Function that is to be
+ called whenever a protocol interface is installed for Protocol by
+ MmInstallProtocolInterface().
+ If Function == NULL and Registration is an existing registration, then the callback is unhooked.
+
+ @param[in] Protocol The unique ID of the protocol for which the event is to be registered.
+ @param[in] Function Points to the notification function.
+ @param[out] Registration A pointer to a memory location to receive the registration value.
+
+ @retval EFI_SUCCESS Successfully returned the registration record
+ that has been added or unhooked.
+ @retval EFI_INVALID_PARAMETER Protocol is NULL or Registration is NULL.
+ @retval EFI_OUT_OF_RESOURCES Not enough memory resource to finish the request.
+ @retval EFI_NOT_FOUND If the registration is not found when Function == NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_REGISTER_PROTOCOL_NOTIFY)(
+ IN CONST EFI_GUID *Protocol,
+ IN EFI_MM_NOTIFY_FN Function,
+ OUT VOID **Registration
+ );
+
+/**
+ Manage MMI of a particular type.
+
+ @param[in] HandlerType Points to the handler type or NULL for root MMI handlers.
+ @param[in] Context Points to an optional context buffer.
+ @param[in,out] CommBuffer Points to the optional communication buffer.
+ @param[in,out] CommBufferSize Points to the size of the optional communication buffer.
+
+ @retval EFI_WARN_INTERRUPT_SOURCE_PENDING Interrupt source was processed successfully but not quiesced.
+ @retval EFI_INTERRUPT_PENDING One or more SMI sources could not be quiesced.
+ @retval EFI_NOT_FOUND Interrupt source was not handled or quiesced.
+ @retval EFI_SUCCESS Interrupt source was handled and quiesced.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_INTERRUPT_MANAGE)(
+ IN CONST EFI_GUID *HandlerType,
+ IN CONST VOID *Context OPTIONAL,
+ IN OUT VOID *CommBuffer OPTIONAL,
+ IN OUT UINTN *CommBufferSize OPTIONAL
+ );
+
+/**
+ Main entry point for an MM handler dispatch or communicate-based callback.
+
+ @param[in] DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
+ @param[in] Context Points to an optional handler context which was specified when the
+ handler was registered.
+ @param[in,out] CommBuffer A pointer to a collection of data in memory that will
+ be conveyed from a non-MM environment into an MM environment.
+ @param[in,out] CommBufferSize The size of the CommBuffer.
+
+ @retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers
+ should still be called.
+ @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should
+ still be called.
+ @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still
+ be called.
+ @retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_HANDLER_ENTRY_POINT)(
+ IN EFI_HANDLE DispatchHandle,
+ IN CONST VOID *Context OPTIONAL,
+ IN OUT VOID *CommBuffer OPTIONAL,
+ IN OUT UINTN *CommBufferSize OPTIONAL
+ );
+
+/**
+ Registers a handler to execute within MM.
+
+ @param[in] Handler Handler service function pointer.
+ @param[in] HandlerType Points to the handler type or NULL for root MMI handlers.
+ @param[out] DispatchHandle On return, contains a unique handle which can be used to later
+ unregister the handler function.
+
+ @retval EFI_SUCCESS MMI handler added successfully.
+ @retval EFI_INVALID_PARAMETER Handler is NULL or DispatchHandle is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_INTERRUPT_REGISTER)(
+ IN EFI_MM_HANDLER_ENTRY_POINT Handler,
+ IN CONST EFI_GUID *HandlerType OPTIONAL,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregister a handler in MM.
+
+ @param[in] DispatchHandle The handle that was specified when the handler was registered.
+
+ @retval EFI_SUCCESS Handler function was successfully unregistered.
+ @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_INTERRUPT_UNREGISTER)(
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Processor information and functionality needed by MM Foundation.
+///
+typedef struct _EFI_MM_ENTRY_CONTEXT {
+ EFI_MM_STARTUP_THIS_AP MmStartupThisAp;
+ ///
+ /// A number between zero and the NumberOfCpus field. This field designates which
+ /// processor is executing the SMM Foundation.
+ ///
+ UINTN CurrentlyExecutingCpu;
+ ///
+ /// The number of possible processors in the platform. This is a 1 based
+ /// counter. This does not indicate the number of processors that entered SMM.
+ ///
+ UINTN NumberOfCpus;
+ ///
+ /// Points to an array, where each element describes the number of bytes in the
+ /// corresponding save state specified by CpuSaveState. There are always
+ /// NumberOfCpus entries in the array.
+ ///
+ UINTN *CpuSaveStateSize;
+ ///
+ /// Points to an array, where each element is a pointer to a CPU save state. The
+ /// corresponding element in CpuSaveStateSize specifies the number of bytes in the
+ /// save state area. There are always NumberOfCpus entries in the array.
+ ///
+ VOID **CpuSaveState;
+} EFI_MM_ENTRY_CONTEXT;
+
+/**
+ This function is the main entry point to the MM Foundation.
+
+ @param[in] MmEntryContext Processor information and functionality needed by MM Foundation.
+**/
+typedef
+VOID
+(EFIAPI *EFI_MM_ENTRY_POINT)(
+ IN CONST EFI_MM_ENTRY_CONTEXT *MmEntryContext
+ );
+
+///
+/// Management Mode System Table (MMST)
+///
+/// The Management Mode System Table (MMST) is a table that contains a collection of common
+/// services for managing MMRAM allocation and providing basic I/O services. These services are
+/// intended for both preboot and runtime usage.
+///
+struct _EFI_MM_SYSTEM_TABLE {
+ ///
+ /// The table header for the SMST.
+ ///
+ EFI_TABLE_HEADER Hdr;
+ ///
+ /// A pointer to a NULL-terminated Unicode string containing the vendor name.
+ /// It is permissible for this pointer to be NULL.
+ ///
+ CHAR16 *MmFirmwareVendor;
+ ///
+ /// The particular revision of the firmware.
+ ///
+ UINT32 MmFirmwareRevision;
+
+ EFI_MM_INSTALL_CONFIGURATION_TABLE MmInstallConfigurationTable;
+
+ ///
+ /// I/O Service
+ ///
+ EFI_MM_CPU_IO_PROTOCOL MmIo;
+
+ ///
+ /// Runtime memory services
+ ///
+ EFI_ALLOCATE_POOL MmAllocatePool;
+ EFI_FREE_POOL MmFreePool;
+ EFI_ALLOCATE_PAGES MmAllocatePages;
+ EFI_FREE_PAGES MmFreePages;
+
+ ///
+ /// MP service
+ ///
+ EFI_MM_STARTUP_THIS_AP MmStartupThisAp;
+
+ ///
+ /// CPU information records
+ ///
+
+ ///
+ /// A number between zero and and the NumberOfCpus field. This field designates
+ /// which processor is executing the SMM infrastructure.
+ ///
+ UINTN CurrentlyExecutingCpu;
+ ///
+ /// The number of possible processors in the platform. This is a 1 based counter.
+ ///
+ UINTN NumberOfCpus;
+ ///
+ /// Points to an array, where each element describes the number of bytes in the
+ /// corresponding save state specified by CpuSaveState. There are always
+ /// NumberOfCpus entries in the array.
+ ///
+ UINTN *CpuSaveStateSize;
+ ///
+ /// Points to an array, where each element is a pointer to a CPU save state. The
+ /// corresponding element in CpuSaveStateSize specifies the number of bytes in the
+ /// save state area. There are always NumberOfCpus entries in the array.
+ ///
+ VOID **CpuSaveState;
+
+ ///
+ /// Extensibility table
+ ///
+
+ ///
+ /// The number of UEFI Configuration Tables in the buffer SmmConfigurationTable.
+ ///
+ UINTN NumberOfTableEntries;
+ ///
+ /// A pointer to the UEFI Configuration Tables. The number of entries in the table is
+ /// NumberOfTableEntries.
+ ///
+ EFI_CONFIGURATION_TABLE *MmConfigurationTable;
+
+ ///
+ /// Protocol services
+ ///
+ EFI_INSTALL_PROTOCOL_INTERFACE MmInstallProtocolInterface;
+ EFI_UNINSTALL_PROTOCOL_INTERFACE MmUninstallProtocolInterface;
+ EFI_HANDLE_PROTOCOL MmHandleProtocol;
+ EFI_MM_REGISTER_PROTOCOL_NOTIFY MmRegisterProtocolNotify;
+ EFI_LOCATE_HANDLE MmLocateHandle;
+ EFI_LOCATE_PROTOCOL MmLocateProtocol;
+
+ ///
+ /// MMI Management functions
+ ///
+ EFI_MM_INTERRUPT_MANAGE MmiManage;
+ EFI_MM_INTERRUPT_REGISTER MmiHandlerRegister;
+ EFI_MM_INTERRUPT_UNREGISTER MmiHandlerUnRegister;
+};
+
+#endif
diff --git a/MdePkg/Include/PiMm.h b/MdePkg/Include/PiMm.h
new file mode 100644
index 0000000..fdb7d27
--- /dev/null
+++ b/MdePkg/Include/PiMm.h
@@ -0,0 +1,25 @@
+/** @file
+
+ Root include file for Mde Package MM modules.
+
+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
+The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php.
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __PI_MM_H__
+#define __PI_MM_H__
+
+#include <Uefi/UefiBaseType.h>
+#include <Uefi/UefiSpec.h>
+
+#include <Pi/PiMmCis.h>
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/DxeMmReadyToLock.h b/MdePkg/Include/Protocol/DxeMmReadyToLock.h
new file mode 100644
index 0000000..9101101
--- /dev/null
+++ b/MdePkg/Include/Protocol/DxeMmReadyToLock.h
@@ -0,0 +1,41 @@
+/** @file
+ DXE MM Ready To Lock protocol introduced in the PI 1.2 specification.
+
+ According to PI 1.4a specification, this UEFI protocol indicates that
+ resources and services that should not be used by the third party code
+ are about to be locked.
+ This protocol is a mandatory protocol published by PI platform code.
+ This protocol in tandem with the End of DXE Event facilitates transition
+ of the platform from the environment where all of the components are
+ under the authority of the platform manufacturer to the environment where
+ third party extensible modules such as UEFI drivers and UEFI applications
+ are executed. The protocol is published immediately after signaling of the
+ End of DXE Event. PI modules that need to lock or protect their resources
+ in anticipation of the invocation of 3rd party extensible modules should
+ register for notification on installation of this protocol and effect the
+ appropriate protections in their notification handlers. For example, PI
+ platform code may choose to use notification handler to lock MM by invoking
+ EFI_MM_ACCESS_PROTOCOL.Lock() function.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _DXE_MM_READY_TO_LOCK_H_
+#define _DXE_MM_READY_TO_LOCK_H_
+
+#define EFI_DXE_MM_READY_TO_LOCK_PROTOCOL_GUID \
+ { \
+ 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e } \
+ }
+
+extern EFI_GUID gEfiDxeMmReadyToLockProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmAccess.h b/MdePkg/Include/Protocol/MmAccess.h
new file mode 100644
index 0000000..b59c798
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmAccess.h
@@ -0,0 +1,133 @@
+/** @file
+ EFI MM Access Protocol as defined in the PI 1.2 specification.
+
+ This protocol is used to control the visibility of the MMRAM on the platform.
+ It abstracts the location and characteristics of MMRAM. The expectation is
+ that the north bridge or memory controller would publish this protocol.
+
+ The principal functionality found in the memory controller includes the following:
+ - Exposing the MMRAM to all non-MM agents, or the "open" state
+ - Shrouding the MMRAM to all but the MM agents, or the "closed" state
+ - Preserving the system integrity, or "locking" the MMRAM, such that the settings cannot be
+ perturbed by either boot service or runtime agents
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_ACCESS_H_
+#define _MM_ACCESS_H_
+
+#define EFI_MM_ACCESS_PROTOCOL_GUID \
+ { \
+ 0xc2702b74, 0x800c, 0x4131, {0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac } \
+ }
+
+
+typedef struct _EFI_MM_ACCESS_PROTOCOL EFI_MM_ACCESS_PROTOCOL;
+
+/**
+ Opens the MMRAM area to be accessible by a boot-service driver.
+
+ This function "opens" MMRAM so that it is visible while not inside of MM. The function should
+ return EFI_UNSUPPORTED if the hardware does not support hiding of MMRAM. The function
+ should return EFI_DEVICE_ERROR if the MMRAM configuration is locked.
+
+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
+
+ @retval EFI_SUCCESS The operation was successful.
+ @retval EFI_UNSUPPORTED The system does not support opening and closing of MMRAM.
+ @retval EFI_DEVICE_ERROR MMRAM cannot be opened, perhaps because it is locked.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_OPEN)(
+ IN EFI_MM_ACCESS_PROTOCOL *This
+ );
+
+/**
+ Inhibits access to the MMRAM.
+
+ This function "closes" MMRAM so that it is not visible while outside of MM. The function should
+ return EFI_UNSUPPORTED if the hardware does not support hiding of MMRAM.
+
+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
+
+ @retval EFI_SUCCESS The operation was successful.
+ @retval EFI_UNSUPPORTED The system does not support opening and closing of MMRAM.
+ @retval EFI_DEVICE_ERROR MMRAM cannot be closed.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_CLOSE)(
+ IN EFI_MM_ACCESS_PROTOCOL *This
+ );
+
+/**
+ Inhibits access to the MMRAM.
+
+ This function prohibits access to the MMRAM region. This function is usually implemented such
+ that it is a write-once operation.
+
+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
+
+ @retval EFI_SUCCESS The device was successfully locked.
+ @retval EFI_UNSUPPORTED The system does not support locking of MMRAM.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_LOCK)(
+ IN EFI_MM_ACCESS_PROTOCOL *This
+ );
+
+/**
+ Queries the memory controller for the possible regions that will support MMRAM.
+
+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
+ @param[in,out] MmramMapSize A pointer to the size, in bytes, of the MmramMemoryMap buffer.
+ @param[in,out] MmramMap A pointer to the buffer in which firmware places the current memory map.
+
+ @retval EFI_SUCCESS The chipset supported the given resource.
+ @retval EFI_BUFFER_TOO_SMALL The MmramMap parameter was too small. The current buffer size
+ needed to hold the memory map is returned in MmramMapSize.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_CAPABILITIES)(
+ IN CONST EFI_MM_ACCESS_PROTOCOL *This,
+ IN OUT UINTN *MmramMapSize,
+ IN OUT EFI_MMRAM_DESCRIPTOR *MmramMap
+ );
+
+///
+/// EFI MM Access Protocol is used to control the visibility of the MMRAM on the platform.
+/// It abstracts the location and characteristics of MMRAM. The platform should report all
+/// MMRAM via EFI_MM_ACCESS_PROTOCOL. The expectation is that the north bridge or memory
+/// controller would publish this protocol.
+///
+struct _EFI_MM_ACCESS_PROTOCOL {
+ EFI_MM_OPEN Open;
+ EFI_MM_CLOSE Close;
+ EFI_MM_LOCK Lock;
+ EFI_MM_CAPABILITIES GetCapabilities;
+ ///
+ /// Indicates the current state of the MMRAM. Set to TRUE if MMRAM is locked.
+ ///
+ BOOLEAN LockState;
+ ///
+ /// Indicates the current state of the MMRAM. Set to TRUE if MMRAM is open.
+ ///
+ BOOLEAN OpenState;
+};
+
+extern EFI_GUID gEfiMmAccessProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmBase.h b/MdePkg/Include/Protocol/MmBase.h
new file mode 100644
index 0000000..23c3bf4
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmBase.h
@@ -0,0 +1,87 @@
+/** @file
+ EFI MM Base Protocol as defined in the PI 1.2 specification.
+
+ This protocol is utilized by all MM drivers to locate the MM infrastructure services and determine
+ whether the driver is being invoked inside MMRAM or outside of MMRAM.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_BASE_H_
+#define _MM_BASE_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_BASE_PROTOCOL_GUID \
+ { \
+ 0xf4ccbfb7, 0xf6e0, 0x47fd, {0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 } \
+ }
+
+typedef struct _EFI_MM_BASE_PROTOCOL EFI_MM_BASE_PROTOCOL;
+
+/**
+ Service to indicate whether the driver is currently executing in the MM Initialization phase.
+
+ This service is used to indicate whether the driver is currently executing in the MM Initialization
+ phase. For MM drivers, this will return TRUE in InMmram while inside the driver's entry point and
+ otherwise FALSE. For combination MM/DXE drivers, this will return FALSE in the DXE launch. For the
+ MM launch, it behaves as an MM driver.
+
+ @param[in] This The EFI_MM_BASE_PROTOCOL instance.
+ @param[out] InMmram Pointer to a Boolean which, on return, indicates that the driver is
+ currently executing inside of MMRAM (TRUE) or outside of MMRAM (FALSE).
+
+ @retval EFI_SUCCESS The call returned successfully.
+ @retval EFI_INVALID_PARAMETER InMmram was NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_INSIDE_OUT)(
+ IN CONST EFI_MM_BASE_PROTOCOL *This,
+ OUT BOOLEAN *InMmram
+ )
+;
+
+/**
+ Returns the location of the Management Mode Service Table (MMST).
+
+ This function returns the location of the Management Mode Service Table (MMST). The use of the
+ API is such that a driver can discover the location of the MMST in its entry point and then cache it in
+ some driver global variable so that the MMST can be invoked in subsequent handlers.
+
+ @param[in] This The EFI_MM_BASE_PROTOCOL instance.
+ @param[in,out] Mmst On return, points to a pointer to the Management Mode Service Table (MMST).
+
+ @retval EFI_SUCCESS The operation was successful.
+ @retval EFI_INVALID_PARAMETER Mmst was invalid.
+ @retval EFI_UNSUPPORTED Not in MM.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_GET_MMST_LOCATION)(
+ IN CONST EFI_MM_BASE_PROTOCOL *This,
+ IN OUT EFI_MM_SYSTEM_TABLE **Mmst
+ )
+;
+
+///
+/// EFI MM Base Protocol is utilized by all MM drivers to locate the MM infrastructure
+/// services and determine whether the driver is being invoked inside MMRAM or outside of MMRAM.
+///
+struct _EFI_MM_BASE_PROTOCOL {
+ EFI_MM_INSIDE_OUT InMm;
+ EFI_MM_GET_MMST_LOCATION GetMmstLocation;
+};
+
+extern EFI_GUID gEfiMmBaseProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmCommunication.h b/MdePkg/Include/Protocol/MmCommunication.h
new file mode 100644
index 0000000..5dbb38e
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmCommunication.h
@@ -0,0 +1,83 @@
+/** @file
+ EFI MM Communication Protocol as defined in the PI 1.2 specification.
+
+ This protocol provides a means of communicating between drivers outside of MM and MMI
+ handlers inside of MM.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_COMMUNICATION_H_
+#define _MM_COMMUNICATION_H_
+
+#pragma pack(1)
+
+///
+/// To avoid confusion in interpreting frames, the communication buffer should always
+/// begin with EFI_MM_COMMUNICATE_HEADER
+///
+typedef struct {
+ ///
+ /// Allows for disambiguation of the message format.
+ ///
+ EFI_GUID HeaderGuid;
+ ///
+ /// Describes the size of Data (in bytes) and does not include the size of the header.
+ ///
+ UINTN MessageLength;
+ ///
+ /// Designates an array of bytes that is MessageLength in size.
+ ///
+ UINT8 Data[1];
+} EFI_MM_COMMUNICATE_HEADER;
+
+#pragma pack()
+
+#define EFI_MM_COMMUNICATION_PROTOCOL_GUID \
+ { \
+ 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 } \
+ }
+
+typedef struct _EFI_MM_COMMUNICATION_PROTOCOL EFI_MM_COMMUNICATION_PROTOCOL;
+
+/**
+ Communicates with a registered handler.
+
+ This function provides a service to send and receive messages from a registered UEFI service.
+
+ @param[in] This The EFI_MM_COMMUNICATION_PROTOCOL instance.
+ @param[in] CommBuffer A pointer to the buffer to convey into MMRAM.
+ @param[in] CommSize The size of the data buffer being passed in.On exit, the size of data
+ being returned. Zero if the handler does not wish to reply with any data.
+
+ @retval EFI_SUCCESS The message was successfully posted.
+ @retval EFI_INVALID_PARAMETER The CommBuffer was NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_COMMUNICATE)(
+ IN CONST EFI_MM_COMMUNICATION_PROTOCOL *This,
+ IN OUT VOID *CommBuffer,
+ IN OUT UINTN *CommSize
+ );
+
+///
+/// EFI MM Communication Protocol provides runtime services for communicating
+/// between DXE drivers and a registered MMI handler.
+///
+struct _EFI_MM_COMMUNICATION_PROTOCOL {
+ EFI_MM_COMMUNICATE Communicate;
+};
+
+extern EFI_GUID gEfiMmCommunicationProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmConfiguration.h b/MdePkg/Include/Protocol/MmConfiguration.h
new file mode 100644
index 0000000..aacd96c
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmConfiguration.h
@@ -0,0 +1,86 @@
+/** @file
+ EFI MM Configuration Protocol as defined in the PI 1.2 specification.
+
+ This protocol is used to:
+ 1) report the portions of MMRAM regions which cannot be used for the MMRAM heap.
+ 2) register the MM Foundation entry point with the processor code. The entry
+ point will be invoked by the MM processor entry code.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_CONFIGURATION_H_
+#define _MM_CONFIGURATION_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_CONFIGURATION_PROTOCOL_GUID \
+ { \
+ 0x26eeb3de, 0xb689, 0x492e, {0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 } \
+ }
+
+///
+/// Structure describing a MMRAM region which cannot be used for the MMRAM heap.
+///
+typedef struct _EFI_MM_RESERVED_MMRAM_REGION {
+ ///
+ /// Starting address of the reserved MMRAM area, as it appears while MMRAM is open.
+ /// Ignored if MmramReservedSize is 0.
+ ///
+ EFI_PHYSICAL_ADDRESS MmramReservedStart;
+ ///
+ /// Number of bytes occupied by the reserved MMRAM area. A size of zero indicates the
+ /// last MMRAM area.
+ ///
+ UINT64 MmramReservedSize;
+} EFI_MM_RESERVED_MMRAM_REGION;
+
+typedef struct _EFI_MM_CONFIGURATION_PROTOCOL EFI_MM_CONFIGURATION_PROTOCOL;
+
+/**
+ Register the MM Foundation entry point.
+
+ This function registers the MM Foundation entry point with the processor code. This entry point
+ will be invoked by the MM Processor entry code.
+
+ @param[in] This The EFI_MM_CONFIGURATION_PROTOCOL instance.
+ @param[in] MmEntryPoint MM Foundation entry point.
+
+ @retval EFI_SUCCESS Success to register MM Entry Point.
+ @retval EFI_INVALID_PARAMETER MmEntryPoint is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_REGISTER_MM_ENTRY)(
+ IN CONST EFI_MM_CONFIGURATION_PROTOCOL *This,
+ IN EFI_MM_ENTRY_POINT MmEntryPoint
+ );
+
+///
+/// The EFI MM Configuration Protocol is a mandatory protocol published by a DXE CPU driver to
+/// indicate which areas within MMRAM are reserved for use by the CPU for any purpose,
+/// such as stack, save state or MM entry point.
+///
+/// The RegistermmEntry() function allows the MM IPL DXE driver to register the MM
+/// Foundation entry point with the MM entry vector code.
+///
+struct _EFI_MM_CONFIGURATION_PROTOCOL {
+ ///
+ /// A pointer to an array MMRAM ranges used by the initial MM entry code.
+ ///
+ EFI_MM_RESERVED_MMRAM_REGION *MmramReservedRegions;
+ EFI_MM_REGISTER_MM_ENTRY RegisterMmEntry;
+};
+
+extern EFI_GUID gEfiMmConfigurationProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmControl.h b/MdePkg/Include/Protocol/MmControl.h
new file mode 100644
index 0000000..c8672c5
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmControl.h
@@ -0,0 +1,106 @@
+/** @file
+ EFI MM Control Protocol as defined in the PI 1.2 specification.
+
+ This protocol is used initiate synchronous MMI activations. This protocol could be published by a
+ processor driver to abstract the MMI IPI or a driver which abstracts the ASIC that is supporting the
+ APM port. Because of the possibility of performing MMI IPI transactions, the ability to generate this
+ event from a platform chipset agent is an optional capability for both IA-32 and x64-based systems.
+
+ The EFI_MM_CONTROL_PROTOCOL is produced by a runtime driver. It provides an
+ abstraction of the platform hardware that generates an MMI. There are often I/O ports that, when
+ accessed, will generate the MMI. Also, the hardware optionally supports the periodic generation of
+ these signals.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_CONTROL_H_
+#define _MM_CONTROL_H_
+
+#include <PiDxe.h>
+
+#define EFI_MM_CONTROL_PROTOCOL_GUID \
+ { \
+ 0x843dc720, 0xab1e, 0x42cb, {0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b} \
+ }
+
+typedef struct _EFI_MM_CONTROL_PROTOCOL EFI_MM_CONTROL_PROTOCOL;
+typedef UINTN EFI_MM_PERIOD;
+
+/**
+ Invokes MMI activation from either the preboot or runtime environment.
+
+ This function generates an MMI.
+
+ @param[in] This The EFI_MM_CONTROL_PROTOCOL instance.
+ @param[in,out] CommandPort The value written to the command port.
+ @param[in,out] DataPort The value written to the data port.
+ @param[in] Periodic Optional mechanism to engender a periodic stream.
+ @param[in] ActivationInterval Optional parameter to repeat at this period one
+ time or, if the Periodic Boolean is set, periodically.
+
+ @retval EFI_SUCCESS The MMI/PMI has been engendered.
+ @retval EFI_DEVICE_ERROR The timing is unsupported.
+ @retval EFI_INVALID_PARAMETER The activation period is unsupported.
+ @retval EFI_INVALID_PARAMETER The last periodic activation has not been cleared.
+ @retval EFI_NOT_STARTED The MM base service has not been initialized.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_ACTIVATE)(
+ IN CONST EFI_MM_CONTROL_PROTOCOL *This,
+ IN OUT UINT8 *CommandPort OPTIONAL,
+ IN OUT UINT8 *DataPort OPTIONAL,
+ IN BOOLEAN Periodic OPTIONAL,
+ IN UINTN ActivationInterval OPTIONAL
+ );
+
+/**
+ Clears any system state that was created in response to the Trigger() call.
+
+ This function acknowledges and causes the deassertion of the MMI activation source.
+
+ @param[in] This The EFI_MM_CONTROL_PROTOCOL instance.
+ @param[in] Periodic Optional parameter to repeat at this period one time
+
+ @retval EFI_SUCCESS The MMI/PMI has been engendered.
+ @retval EFI_DEVICE_ERROR The source could not be cleared.
+ @retval EFI_INVALID_PARAMETER The service did not support the Periodic input argument.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_DEACTIVATE)(
+ IN CONST EFI_MM_CONTROL_PROTOCOL *This,
+ IN BOOLEAN Periodic OPTIONAL
+ );
+
+///
+/// The EFI_MM_CONTROL_PROTOCOL is produced by a runtime driver. It provides an
+/// abstraction of the platform hardware that generates an MMI. There are often I/O ports that, when
+/// accessed, will generate the MMI. Also, the hardware optionally supports the periodic generation of
+/// these signals.
+///
+struct _EFI_MM_CONTROL_PROTOCOL {
+ EFI_MM_ACTIVATE Trigger;
+ EFI_MM_DEACTIVATE Clear;
+ ///
+ /// Minimum interval at which the platform can set the period. A maximum is not
+ /// specified in that the MM infrastructure code can emulate a maximum interval that is
+ /// greater than the hardware capabilities by using software emulation in the MM
+ /// infrastructure code.
+ ///
+ EFI_MM_PERIOD MinimumTriggerPeriod;
+};
+
+extern EFI_GUID gEfiMmControlProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmCpu.h b/MdePkg/Include/Protocol/MmCpu.h
new file mode 100644
index 0000000..d6ddbcd
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmCpu.h
@@ -0,0 +1,247 @@
+/** @file
+ EFI MM CPU Protocol as defined in the PI 1.2 specification.
+
+ This protocol allows MM drivers to access architecture-standard registers from any of the CPU
+ save state areas. In some cases, difference processors provide the same information in the save state,
+ but not in the same format. These so-called pseudo-registers provide this information in a standard
+ format.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_CPU_H_
+#define _MM_CPU_H_
+
+#define EFI_MM_CPU_PROTOCOL_GUID \
+ { \
+ 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 } \
+ }
+
+///
+/// Save State register index
+///
+typedef enum {
+ ///
+ /// x86/X64 standard registers
+ ///
+ EFI_MM_SAVE_STATE_REGISTER_GDTBASE = 4,
+ EFI_MM_SAVE_STATE_REGISTER_IDTBASE = 5,
+ EFI_MM_SAVE_STATE_REGISTER_LDTBASE = 6,
+ EFI_MM_SAVE_STATE_REGISTER_GDTLIMIT = 7,
+ EFI_MM_SAVE_STATE_REGISTER_IDTLIMIT = 8,
+ EFI_MM_SAVE_STATE_REGISTER_LDTLIMIT = 9,
+ EFI_MM_SAVE_STATE_REGISTER_LDTINFO = 10,
+ EFI_MM_SAVE_STATE_REGISTER_ES = 20,
+ EFI_MM_SAVE_STATE_REGISTER_CS = 21,
+ EFI_MM_SAVE_STATE_REGISTER_SS = 22,
+ EFI_MM_SAVE_STATE_REGISTER_DS = 23,
+ EFI_MM_SAVE_STATE_REGISTER_FS = 24,
+ EFI_MM_SAVE_STATE_REGISTER_GS = 25,
+ EFI_MM_SAVE_STATE_REGISTER_LDTR_SEL = 26,
+ EFI_MM_SAVE_STATE_REGISTER_TR_SEL = 27,
+ EFI_MM_SAVE_STATE_REGISTER_DR7 = 28,
+ EFI_MM_SAVE_STATE_REGISTER_DR6 = 29,
+ EFI_MM_SAVE_STATE_REGISTER_R8 = 30,
+ EFI_MM_SAVE_STATE_REGISTER_R9 = 31,
+ EFI_MM_SAVE_STATE_REGISTER_R10 = 32,
+ EFI_MM_SAVE_STATE_REGISTER_R11 = 33,
+ EFI_MM_SAVE_STATE_REGISTER_R12 = 34,
+ EFI_MM_SAVE_STATE_REGISTER_R13 = 35,
+ EFI_MM_SAVE_STATE_REGISTER_R14 = 36,
+ EFI_MM_SAVE_STATE_REGISTER_R15 = 37,
+ EFI_MM_SAVE_STATE_REGISTER_RAX = 38,
+ EFI_MM_SAVE_STATE_REGISTER_RBX = 39,
+ EFI_MM_SAVE_STATE_REGISTER_RCX = 40,
+ EFI_MM_SAVE_STATE_REGISTER_RDX = 41,
+ EFI_MM_SAVE_STATE_REGISTER_RSP = 42,
+ EFI_MM_SAVE_STATE_REGISTER_RBP = 43,
+ EFI_MM_SAVE_STATE_REGISTER_RSI = 44,
+ EFI_MM_SAVE_STATE_REGISTER_RDI = 45,
+ EFI_MM_SAVE_STATE_REGISTER_RIP = 46,
+ EFI_MM_SAVE_STATE_REGISTER_RFLAGS = 51,
+ EFI_MM_SAVE_STATE_REGISTER_CR0 = 52,
+ EFI_MM_SAVE_STATE_REGISTER_CR3 = 53,
+ EFI_MM_SAVE_STATE_REGISTER_CR4 = 54,
+ EFI_MM_SAVE_STATE_REGISTER_FCW = 256,
+ EFI_MM_SAVE_STATE_REGISTER_FSW = 257,
+ EFI_MM_SAVE_STATE_REGISTER_FTW = 258,
+ EFI_MM_SAVE_STATE_REGISTER_OPCODE = 259,
+ EFI_MM_SAVE_STATE_REGISTER_FP_EIP = 260,
+ EFI_MM_SAVE_STATE_REGISTER_FP_CS = 261,
+ EFI_MM_SAVE_STATE_REGISTER_DATAOFFSET = 262,
+ EFI_MM_SAVE_STATE_REGISTER_FP_DS = 263,
+ EFI_MM_SAVE_STATE_REGISTER_MM0 = 264,
+ EFI_MM_SAVE_STATE_REGISTER_MM1 = 265,
+ EFI_MM_SAVE_STATE_REGISTER_MM2 = 266,
+ EFI_MM_SAVE_STATE_REGISTER_MM3 = 267,
+ EFI_MM_SAVE_STATE_REGISTER_MM4 = 268,
+ EFI_MM_SAVE_STATE_REGISTER_MM5 = 269,
+ EFI_MM_SAVE_STATE_REGISTER_MM6 = 270,
+ EFI_MM_SAVE_STATE_REGISTER_MM7 = 271,
+ EFI_MM_SAVE_STATE_REGISTER_XMM0 = 272,
+ EFI_MM_SAVE_STATE_REGISTER_XMM1 = 273,
+ EFI_MM_SAVE_STATE_REGISTER_XMM2 = 274,
+ EFI_MM_SAVE_STATE_REGISTER_XMM3 = 275,
+ EFI_MM_SAVE_STATE_REGISTER_XMM4 = 276,
+ EFI_MM_SAVE_STATE_REGISTER_XMM5 = 277,
+ EFI_MM_SAVE_STATE_REGISTER_XMM6 = 278,
+ EFI_MM_SAVE_STATE_REGISTER_XMM7 = 279,
+ EFI_MM_SAVE_STATE_REGISTER_XMM8 = 280,
+ EFI_MM_SAVE_STATE_REGISTER_XMM9 = 281,
+ EFI_MM_SAVE_STATE_REGISTER_XMM10 = 282,
+ EFI_MM_SAVE_STATE_REGISTER_XMM11 = 283,
+ EFI_MM_SAVE_STATE_REGISTER_XMM12 = 284,
+ EFI_MM_SAVE_STATE_REGISTER_XMM13 = 285,
+ EFI_MM_SAVE_STATE_REGISTER_XMM14 = 286,
+ EFI_MM_SAVE_STATE_REGISTER_XMM15 = 287,
+ ///
+ /// Pseudo-Registers
+ ///
+ EFI_MM_SAVE_STATE_REGISTER_IO = 512,
+ EFI_MM_SAVE_STATE_REGISTER_LMA = 513,
+ EFI_MM_SAVE_STATE_REGISTER_PROCESSOR_ID = 514
+} EFI_MM_SAVE_STATE_REGISTER;
+
+///
+/// The EFI_MM_SAVE_STATE_REGISTER_LMA pseudo-register values
+/// If the processor acts in 32-bit mode at the time the MMI occurred, the pseudo register value
+/// EFI_MM_SAVE_STATE_REGISTER_LMA_32BIT is returned in Buffer. Otherwise,
+/// EFI_MM_SAVE_STATE_REGISTER_LMA_64BIT is returned in Buffer.
+///
+#define EFI_MM_SAVE_STATE_REGISTER_LMA_32BIT 32
+#define EFI_MM_SAVE_STATE_REGISTER_LMA_64BIT 64
+
+///
+/// Size width of I/O instruction
+///
+typedef enum {
+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT8 = 0,
+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT16 = 1,
+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT32 = 2,
+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT64 = 3
+} EFI_MM_SAVE_STATE_IO_WIDTH;
+
+///
+/// Types of I/O instruction
+///
+typedef enum {
+ EFI_MM_SAVE_STATE_IO_TYPE_INPUT = 1,
+ EFI_MM_SAVE_STATE_IO_TYPE_OUTPUT = 2,
+ EFI_MM_SAVE_STATE_IO_TYPE_STRING = 4,
+ EFI_MM_SAVE_STATE_IO_TYPE_REP_PREFIX = 8
+} EFI_MM_SAVE_STATE_IO_TYPE;
+
+///
+/// Structure of the data which is returned when ReadSaveState() is called with
+/// EFI_MM_SAVE_STATE_REGISTER_IO. If there was no I/O then ReadSaveState() will
+/// return EFI_NOT_FOUND.
+///
+/// This structure describes the I/O operation which was in process when the MMI was generated.
+///
+typedef struct _EFI_MM_SAVE_STATE_IO_INFO {
+ ///
+ /// For input instruction (IN, INS), this is data read before the MMI occurred. For output
+ /// instructions (OUT, OUTS) this is data that was written before the MMI occurred. The
+ /// width of the data is specified by IoWidth.
+ ///
+ UINT64 IoData;
+ ///
+ /// The I/O port that was being accessed when the MMI was triggered.
+ ///
+ UINT16 IoPort;
+ ///
+ /// Defines the size width (UINT8, UINT16, UINT32, UINT64) for IoData.
+ ///
+ EFI_MM_SAVE_STATE_IO_WIDTH IoWidth;
+ ///
+ /// Defines type of I/O instruction.
+ ///
+ EFI_MM_SAVE_STATE_IO_TYPE IoType;
+} EFI_MM_SAVE_STATE_IO_INFO;
+
+typedef struct _EFI_MM_CPU_PROTOCOL EFI_MM_CPU_PROTOCOL;
+
+/**
+ Read data from the CPU save state.
+
+ This function is used to read the specified number of bytes of the specified register from the CPU
+ save state of the specified CPU and place the value into the buffer. If the CPU does not support the
+ specified register Register, then EFI_NOT_FOUND should be returned. If the CPU does not
+ support the specified register width Width, then EFI_INVALID_PARAMETER is returned.
+
+ @param[in] This The EFI_MM_CPU_PROTOCOL instance.
+ @param[in] Width The number of bytes to read from the CPU save state.
+ @param[in] Register Specifies the CPU register to read form the save state.
+ @param[in] CpuIndex Specifies the zero-based index of the CPU save state.
+ @param[out] Buffer Upon return, this holds the CPU register value read from the save state.
+
+ @retval EFI_SUCCESS The register was read from Save State.
+ @retval EFI_NOT_FOUND The register is not defined for the Save State of Processor.
+ @retval EFI_INVALID_PARAMETER Input parameters are not valid, for example, Processor No or register width
+ is not correct.This or Buffer is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_READ_SAVE_STATE)(
+ IN CONST EFI_MM_CPU_PROTOCOL *This,
+ IN UINTN Width,
+ IN EFI_MM_SAVE_STATE_REGISTER Register,
+ IN UINTN CpuIndex,
+ OUT VOID *Buffer
+ );
+
+
+/**
+ Write data to the CPU save state.
+
+ This function is used to write the specified number of bytes of the specified register to the CPU save
+ state of the specified CPU and place the value into the buffer. If the CPU does not support the
+ specified register Register, then EFI_UNSUPPORTED should be returned. If the CPU does not
+ support the specified register width Width, then EFI_INVALID_PARAMETER is returned.
+
+ @param[in] This The EFI_MM_CPU_PROTOCOL instance.
+ @param[in] Width The number of bytes to write to the CPU save state.
+ @param[in] Register Specifies the CPU register to write to the save state.
+ @param[in] CpuIndex Specifies the zero-based index of the CPU save state.
+ @param[in] Buffer Upon entry, this holds the new CPU register value.
+
+ @retval EFI_SUCCESS The register was written to Save State.
+ @retval EFI_NOT_FOUND The register is not defined for the Save State of Processor.
+ @retval EFI_INVALID_PARAMETER Input parameters are not valid. For example:
+ ProcessorIndex or Width is not correct.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_WRITE_SAVE_STATE)(
+ IN CONST EFI_MM_CPU_PROTOCOL *This,
+ IN UINTN Width,
+ IN EFI_MM_SAVE_STATE_REGISTER Register,
+ IN UINTN CpuIndex,
+ IN CONST VOID *Buffer
+ );
+
+///
+/// EFI MM CPU Protocol provides access to CPU-related information while in MM.
+///
+/// This protocol allows MM drivers to access architecture-standard registers from any of the CPU
+/// save state areas. In some cases, difference processors provide the same information in the save state,
+/// but not in the same format. These so-called pseudo-registers provide this information in a standard
+/// format.
+///
+struct _EFI_MM_CPU_PROTOCOL {
+ EFI_MM_READ_SAVE_STATE ReadSaveState;
+ EFI_MM_WRITE_SAVE_STATE WriteSaveState;
+};
+
+extern EFI_GUID gEfiMmCpuProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmCpuIo.h b/MdePkg/Include/Protocol/MmCpuIo.h
new file mode 100644
index 0000000..9fda26c
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmCpuIo.h
@@ -0,0 +1,96 @@
+/** @file
+ MM CPU I/O 2 protocol as defined in the PI 1.2 specification.
+
+ This protocol provides CPU I/O and memory access within MM.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_CPU_IO_H_
+#define _MM_CPU_IO_H_
+
+#define EFI_MM_CPU_IO_PROTOCOL_GUID \
+ { \
+ 0x3242A9D8, 0xCE70, 0x4AA0, { 0x95, 0x5D, 0x5E, 0x7B, 0x14, 0x0D, 0xE4, 0xD2 } \
+ }
+
+typedef struct _EFI_MM_CPU_IO_PROTOCOL EFI_MM_CPU_IO_PROTOCOL;
+
+///
+/// Width of the MM CPU I/O operations
+///
+typedef enum {
+ MM_IO_UINT8 = 0,
+ MM_IO_UINT16 = 1,
+ MM_IO_UINT32 = 2,
+ MM_IO_UINT64 = 3
+} EFI_MM_IO_WIDTH;
+
+/**
+ Provides the basic memory and I/O interfaces used toabstract accesses to devices.
+
+ The I/O operations are carried out exactly as requested. The caller is
+ responsible for any alignment and I/O width issues that the bus, device,
+ platform, or type of I/O might require.
+
+ @param[in] This The EFI_MM_CPU_IO_PROTOCOL instance.
+ @param[in] Width Signifies the width of the I/O operations.
+ @param[in] Address The base address of the I/O operations. The caller is
+ responsible for aligning the Address if required.
+ @param[in] Count The number of I/O operations to perform.
+ @param[in,out] Buffer For read operations, the destination buffer to store
+ the results. For write operations, the source buffer
+ from which to write data.
+
+ @retval EFI_SUCCESS The data was read from or written to the device.
+ @retval EFI_UNSUPPORTED The Address is not valid for this system.
+ @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid.
+ @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack
+ of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_CPU_IO)(
+ IN CONST EFI_MM_CPU_IO_PROTOCOL *This,
+ IN EFI_MM_IO_WIDTH Width,
+ IN UINT64 Address,
+ IN UINTN Count,
+ IN OUT VOID *Buffer
+ );
+
+typedef struct {
+ ///
+ /// This service provides the various modalities of memory and I/O read.
+ ///
+ EFI_MM_CPU_IO Read;
+ ///
+ /// This service provides the various modalities of memory and I/O write.
+ ///
+ EFI_MM_CPU_IO Write;
+} EFI_MM_IO_ACCESS;
+
+///
+/// MM CPU I/O Protocol provides CPU I/O and memory access within MM.
+///
+struct _EFI_MM_CPU_IO_PROTOCOL {
+ ///
+ /// Allows reads and writes to memory-mapped I/O space.
+ ///
+ EFI_MM_IO_ACCESS Mem;
+ ///
+ /// Allows reads and writes to I/O space.
+ ///
+ EFI_MM_IO_ACCESS Io;
+};
+
+extern EFI_GUID gEfiMmCpuIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmEndOfDxe.h b/MdePkg/Include/Protocol/MmEndOfDxe.h
new file mode 100644
index 0000000..6c3f17a
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmEndOfDxe.h
@@ -0,0 +1,33 @@
+/** @file
+ MM End Of Dxe protocol introduced in the PI 1.2.1 specification.
+
+ According to PI 1.4a specification, this protocol indicates end of the
+ execution phase when all of the components are under the authority of
+ the platform manufacturer.
+ This protocol is a mandatory protocol published by MM Foundation code.
+ This protocol is an MM counterpart of the End of DXE Event.
+ This protocol prorogates End of DXE notification into MM environment.
+ This protocol is installed prior to installation of the MM Ready to Lock Protocol.
+
+ Copyright (c) 2012 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_END_OF_DXE_H_
+#define _MM_END_OF_DXE_H_
+
+#define EFI_MM_END_OF_DXE_PROTOCOL_GUID \
+ { \
+ 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d } \
+ }
+
+extern EFI_GUID gEfiMmEndOfDxeProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmGpiDispatch.h b/MdePkg/Include/Protocol/MmGpiDispatch.h
new file mode 100644
index 0000000..5682e75
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmGpiDispatch.h
@@ -0,0 +1,125 @@
+/** @file
+ MM General Purpose Input (GPI) Dispatch Protocol as defined in PI 1.1 Specification
+ Volume 4 Management Mode Core Interface.
+
+ This protocol provides the parent dispatch service for the General Purpose Input
+ (GPI) MMI source generator.
+
+ The EFI_MM_GPI_DISPATCH_PROTOCOL provides the ability to install child handlers for the
+ given event types. Several inputs can be enabled. This purpose of this interface is to generate an
+ MMI in response to any of these inputs having a true value provided.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ @par Revision Reference:
+ This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _MM_GPI_DISPATCH_H_
+#define _MM_GPI_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_GPI_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 } \
+ }
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+ ///
+ /// A number from one of 2^64 possible GPIs that can generate an MMI. A
+ /// 0 corresponds to logical GPI[0]; 1 corresponds to logical GPI[1]; and
+ /// GpiNum of N corresponds to GPI[N], where N can span from 0 to 2^64-1.
+ ///
+ UINT64 GpiNum;
+} EFI_MM_GPI_REGISTER_CONTEXT;
+
+typedef struct _EFI_MM_GPI_DISPATCH_PROTOCOL EFI_MM_GPI_DISPATCH_PROTOCOL;
+
+/**
+ Registers a child MMI source dispatch function with a parent MM driver.
+
+ This service registers a function (DispatchFunction) which will be called when an MMI is
+ generated because of one or more of the GPIs specified by RegisterContext. On return,
+ DispatchHandle contains a unique handle which may be used later to unregister the function
+ using UnRegister().
+ The DispatchFunction will be called with Context set to the same value as was passed into
+ this function in RegisterContext and with CommBuffer pointing to another instance of
+ EFI_MM_GPI_REGISTER_CONTEXT describing the GPIs which actually caused the MMI and
+ CommBufferSize pointing to the size of the structure.
+
+ @param[in] This Pointer to the EFI_MM_GPI_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when the specified GPI causes an MMI.
+ @param[in] RegisterContext Pointer to the dispatch function's context.
+ The caller fills this context in before calling
+ the register function to indicate to the register
+ function the GPI(s) for which the dispatch function
+ should be invoked.
+ @param[out] DispatchHandle Handle generated by the dispatcher to track the
+ function instance.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The GPI input value
+ is not within valid range.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_GPI_REGISTER)(
+ IN CONST EFI_MM_GPI_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN CONST EFI_MM_GPI_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregisters a General Purpose Input (GPI) service.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called when the GPI triggers an MMI.
+
+ @param[in] This Pointer to the EFI_MM_GPI_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the service to remove.
+
+ @retval EFI_SUCCESS Handle of the service to remove.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_GPI_UNREGISTER)(
+ IN CONST EFI_MM_GPI_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Interface structure for the MM GPI MMI Dispatch Protocol
+///
+/// The MM GPI MMI Dispatch Protocol provides the parent dispatch service
+/// for the General Purpose Input (GPI) MMI source generator.
+///
+struct _EFI_MM_GPI_DISPATCH_PROTOCOL {
+ EFI_MM_GPI_REGISTER Register;
+ EFI_MM_GPI_UNREGISTER UnRegister;
+ ///
+ /// Denotes the maximum value of inputs that can have handlers attached.
+ ///
+ UINTN NumSupportedGpis;
+};
+
+extern EFI_GUID gEfiMmGpiDispatchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmIoTrapDispatch.h b/MdePkg/Include/Protocol/MmIoTrapDispatch.h
new file mode 100644
index 0000000..ae116a0
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmIoTrapDispatch.h
@@ -0,0 +1,136 @@
+/** @file
+ MM IO Trap Dispatch Protocol as defined in PI 1.1 Specification
+ Volume 4 Management Mode Core Interface.
+
+ This protocol provides a parent dispatch service for IO trap MMI sources.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ @par Revision Reference:
+ This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _MM_IO_TRAP_DISPATCH_H_
+#define _MM_IO_TRAP_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_IO_TRAP_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 } \
+ }
+
+///
+/// IO Trap valid types
+///
+typedef enum {
+ WriteTrap,
+ ReadTrap,
+ ReadWriteTrap,
+ IoTrapTypeMaximum
+} EFI_MM_IO_TRAP_DISPATCH_TYPE;
+
+///
+/// IO Trap context structure containing information about the
+/// IO trap event that should invoke the handler
+///
+typedef struct {
+ UINT16 Address;
+ UINT16 Length;
+ EFI_MM_IO_TRAP_DISPATCH_TYPE Type;
+} EFI_MM_IO_TRAP_REGISTER_CONTEXT;
+
+///
+/// IO Trap context structure containing information about the IO trap that occurred
+///
+typedef struct {
+ UINT32 WriteData;
+} EFI_MM_IO_TRAP_CONTEXT;
+
+typedef struct _EFI_MM_IO_TRAP_DISPATCH_PROTOCOL EFI_MM_IO_TRAP_DISPATCH_PROTOCOL;
+
+/**
+ Register an IO trap MMI child handler for a specified MMI.
+
+ This service registers a function (DispatchFunction) which will be called when an MMI is
+ generated because of an access to an I/O port specified by RegisterContext. On return,
+ DispatchHandle contains a unique handle which may be used later to unregister the function
+ using UnRegister(). If the base of the I/O range specified is zero, then an I/O range with the
+ specified length and characteristics will be allocated and the Address field in RegisterContext
+ updated. If no range could be allocated, then EFI_OUT_OF_RESOURCES will be returned.
+
+ The service will not perform GCD allocation if the base address is non-zero or
+ EFI_MM_READY_TO_LOCK has been installed. In this case, the caller is responsible for the
+ existence and allocation of the specific IO range.
+ An error may be returned if some or all of the requested resources conflict with an existing IO trap
+ child handler.
+
+ It is not required that implementations will allow multiple children for a single IO trap MMI source.
+ Some implementations may support multiple children.
+ The DispatchFunction will be called with Context updated to contain information
+ concerning the I/O action that actually happened and is passed in RegisterContext, with
+ CommBuffer pointing to the data actually written and CommBufferSize pointing to the size of
+ the data in CommBuffer.
+
+ @param[in] This Pointer to the EFI_MM_IO_TRAP_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when I/O trap location is accessed.
+ @param[in] RegisterContext Pointer to the dispatch function's context. The caller fills this
+ context in before calling the register function to indicate to the register
+ function the IO trap MMI source for which the dispatch function should be invoked.
+ @param[out] DispatchHandle Handle of the dispatch function, for when interfacing with the parent MM driver.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully registered.
+ @retval EFI_DEVICE_ERROR The driver was unable to complete due to hardware error.
+ @retval EFI_OUT_OF_RESOURCES Insufficient resources are available to fulfill the IO trap range request.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The input value is not within a valid range.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_IO_TRAP_DISPATCH_REGISTER)(
+ IN CONST EFI_MM_IO_TRAP_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN OUT EFI_MM_IO_TRAP_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregister a child MMI source dispatch function with a parent MM driver.
+
+ This service removes a previously installed child dispatch handler. This does not guarantee that the
+ system resources will be freed from the GCD.
+
+ @param[in] This Pointer to the EFI_MM_IO_TRAP_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the child service to remove.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully unregistered.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_IO_TRAP_DISPATCH_UNREGISTER)(
+ IN CONST EFI_MM_IO_TRAP_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Interface structure for the MM IO Trap Dispatch Protocol.
+///
+/// This protocol provides a parent dispatch service for IO trap MMI sources.
+///
+struct _EFI_MM_IO_TRAP_DISPATCH_PROTOCOL {
+ EFI_MM_IO_TRAP_DISPATCH_REGISTER Register;
+ EFI_MM_IO_TRAP_DISPATCH_UNREGISTER UnRegister;
+};
+
+extern EFI_GUID gEfiMmIoTrapDispatchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmPciRootBridgeIo.h b/MdePkg/Include/Protocol/MmPciRootBridgeIo.h
new file mode 100644
index 0000000..a3f3946
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmPciRootBridgeIo.h
@@ -0,0 +1,37 @@
+/** @file
+ MM PCI Root Bridge IO protocol as defined in the PI 1.2 specification.
+
+ This protocol provides PCI I/O and memory access within MM.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_PCI_ROOT_BRIDGE_IO_H_
+#define _MM_PCI_ROOT_BRIDGE_IO_H_
+
+#include <Protocol/PciRootBridgeIo.h>
+
+#define EFI_MM_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
+ { \
+ 0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea } \
+ }
+
+///
+/// This protocol provides the same functionality as the PCI Root Bridge I/O Protocol defined in the
+/// UEFI 2.1 Specifcation, section 13.2, except that the functions for Map() and Unmap() may return
+/// EFI_UNSUPPORTED.
+///
+typedef EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL EFI_MM_PCI_ROOT_BRIDGE_IO_PROTOCOL;
+
+extern EFI_GUID gEfiMmPciRootBridgeIoProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h b/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
new file mode 100644
index 0000000..4f88dc8
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
@@ -0,0 +1,170 @@
+/** @file
+ MM Periodic Timer Dispatch Protocol as defined in PI 1.1 Specification
+ Volume 4 Management Mode Core Interface.
+
+ This protocol provides the parent dispatch service for the periodical timer MMI source generator.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ @par Revision Reference:
+ This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _MM_PERIODIC_TIMER_DISPATCH_H_
+#define _MM_PERIODIC_TIMER_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 } \
+ }
+
+///
+/// Example: A chipset supports periodic MMIs on every 64ms or 2 seconds.
+/// A child wishes schedule a period MMI to fire on a period of 3 seconds, there
+/// are several ways to approach the problem:
+/// 1. The child may accept a 4 second periodic rate, in which case it registers with
+/// Period = 40000
+/// MmiTickInterval = 20000
+/// The resulting MMI will occur every 2 seconds with the child called back on
+/// every 2nd MMI.
+/// NOTE: the same result would occur if the child set MmiTickInterval = 0.
+/// 2. The child may choose the finer granularity MMI (64ms):
+/// Period = 30000
+/// MmiTickInterval = 640
+/// The resulting MMI will occur every 64ms with the child called back on
+/// every 47th MMI.
+/// NOTE: the child driver should be aware that this will result in more
+/// MMIs occuring during system runtime which can negatively impact system
+/// performance.
+///
+typedef struct {
+ ///
+ /// The minimum period of time in 100 nanosecond units that the child gets called. The
+ /// child will be called back after a time greater than the time Period.
+ ///
+ UINT64 Period;
+ ///
+ /// The period of time interval between MMIs. Children of this interface should use this
+ /// field when registering for periodic timer intervals when a finer granularity periodic
+ /// MMI is desired.
+ ///
+ UINT64 MmiTickInterval;
+} EFI_MM_PERIODIC_TIMER_REGISTER_CONTEXT;
+
+///
+/// The DispatchFunction will be called with Context set to the same value as was passed into
+/// Register() in RegisterContext and with CommBuffer pointing to an instance of
+/// EFI_MM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its size.
+///
+typedef struct {
+ ///
+ /// ElapsedTime is the actual time in 100 nanosecond units elapsed since last called, a
+ /// value of 0 indicates an unknown amount of time.
+ ///
+ UINT64 ElapsedTime;
+} EFI_MM_PERIODIC_TIMER_CONTEXT;
+
+typedef struct _EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL;
+
+/**
+ Register a child MMI source dispatch function for MM periodic timer.
+
+ This service registers a function (DispatchFunction) which will be called when at least the
+ amount of time specified by RegisterContext has elapsed. On return, DispatchHandle
+ contains a unique handle which may be used later to unregister the function using UnRegister().
+ The DispatchFunction will be called with Context set to the same value as was passed into
+ this function in RegisterContext and with CommBuffer pointing to an instance of
+ EFI_MM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its size.
+
+ @param[in] This Pointer to the EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when at least the specified amount
+ of time has elapsed.
+ @param[in] RegisterContext Pointer to the dispatch function's context.
+ The caller fills this context in before calling
+ the register function to indicate to the register
+ function the period at which the dispatch function
+ should be invoked.
+ @param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The period input value
+ is not within valid range.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_PERIODIC_TIMER_REGISTER)(
+ IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN CONST EFI_MM_PERIODIC_TIMER_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregisters a periodic timer service.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called when the time has elapsed.
+
+ @param[in] This Pointer to the EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the service to remove.
+
+ @retval EFI_SUCCESS The service has been successfully removed.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_PERIODIC_TIMER_UNREGISTER)(
+ IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+/**
+ Returns the next MMI tick period supported by the chipset.
+
+ The order returned is from longest to shortest interval period.
+
+ @param[in] This Pointer to the EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
+ @param[in,out] MmiTickInterval Pointer to pointer of next shorter MMI interval
+ period supported by the child. This parameter works as a get-first,
+ get-next field.The first time this function is called, *MmiTickInterval
+ should be set to NULL to get the longest MMI interval.The returned
+ *MmiTickInterval should be passed in on subsequent calls to get the
+ next shorter interval period until *MmiTickInterval = NULL.
+
+ @retval EFI_SUCCESS The service returned successfully.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_PERIODIC_TIMER_INTERVAL)(
+ IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
+ IN OUT UINT64 **MmiTickInterval
+ );
+
+///
+/// Interface structure for the MM Periodic Timer Dispatch Protocol
+///
+/// This protocol provides the parent dispatch service for the periodical timer MMI source generator.
+///
+struct _EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL {
+ EFI_MM_PERIODIC_TIMER_REGISTER Register;
+ EFI_MM_PERIODIC_TIMER_UNREGISTER UnRegister;
+ EFI_MM_PERIODIC_TIMER_INTERVAL GetNextShorterInterval;
+};
+
+extern EFI_GUID gEfiMmPeriodicTimerDispatchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmPowerButtonDispatch.h b/MdePkg/Include/Protocol/MmPowerButtonDispatch.h
new file mode 100644
index 0000000..7f1a4e2
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmPowerButtonDispatch.h
@@ -0,0 +1,117 @@
+/** @file
+ MM Power Button Dispatch Protocol as defined in PI 1.1 Specification
+ Volume 4 Management Mode Core Interface.
+
+ This protocol provides the parent dispatch service for the power button MMI source generator.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ @par Revision Reference:
+ This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _MM_POWER_BUTTON_DISPATCH_H_
+#define _MM_POWER_BUTTON_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d } \
+ }
+
+///
+/// Power Button phases.
+///
+typedef enum {
+ EfiPowerButtonEntry,
+ EfiPowerButtonExit,
+ EfiPowerButtonMax
+} EFI_POWER_BUTTON_PHASE;
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+ ///
+ /// Designates whether this handler should be invoked upon entry or exit.
+ ///
+ EFI_POWER_BUTTON_PHASE Phase;
+} EFI_MM_POWER_BUTTON_REGISTER_CONTEXT;
+
+typedef struct _EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL;
+
+/**
+ Provides the parent dispatch service for a power button event.
+
+ This service registers a function (DispatchFunction) which will be called when an MMI is
+ generated because the power button was pressed or released, as specified by RegisterContext.
+ On return, DispatchHandle contains a unique handle which may be used later to unregister the
+ function using UnRegister().
+ The DispatchFunction will be called with Context set to the same value as was passed into
+ this function in RegisterContext and with CommBuffer and CommBufferSize set to NULL.
+
+ @param[in] This Pointer to the EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when power button is pressed or released.
+ @param[in] RegisterContext Pointer to the dispatch function's context. The caller fills in this context
+ before calling the Register() function to indicate to the Register() function
+ the power button MMI phase for which the dispatch function should be invoked.
+ @param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The power button input value
+ is not within valid range.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_POWER_BUTTON_REGISTER)(
+ IN CONST EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN EFI_MM_POWER_BUTTON_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregisters a power-button service.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called when the standby button is pressed or released.
+
+ @param[in] This Pointer to the EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the service to remove.
+
+ @retval EFI_SUCCESS The service has been successfully removed.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_POWER_BUTTON_UNREGISTER)(
+ IN CONST EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Interface structure for the MM Power Button Dispatch Protocol.
+///
+/// This protocol provides the parent dispatch service for the power button MMI source generator.
+///
+struct _EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL {
+ EFI_MM_POWER_BUTTON_REGISTER Register;
+ EFI_MM_POWER_BUTTON_UNREGISTER UnRegister;
+};
+
+extern EFI_GUID gEfiMmPowerButtonDispatchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmReadyToLock.h b/MdePkg/Include/Protocol/MmReadyToLock.h
new file mode 100644
index 0000000..7752c71
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmReadyToLock.h
@@ -0,0 +1,35 @@
+/** @file
+ MM Ready To Lock protocol introduced in the PI 1.2 specification.
+
+ According to PI 1.4a specification, this MM protocol indicates that
+ MM resources and services that should not be used by the third party
+ code are about to be locked.
+ This protocol is a mandatory protocol published by the MM Foundation
+ code when the system is preparing to lock certain resources and interfaces
+ in anticipation of the invocation of 3rd party extensible modules.
+ This protocol is an MM counterpart of the DXE MM Ready to Lock Protocol.
+ This protocol prorogates resource locking notification into MM environment.
+ This protocol is installed after installation of the MM End of DXE Protocol.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_READY_TO_LOCK_H_
+#define _MM_READY_TO_LOCK_H_
+
+#define EFI_MM_READY_TO_LOCK_PROTOCOL_GUID \
+ { \
+ 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 } \
+ }
+
+extern EFI_GUID gEfiMmReadyToLockProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h b/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
new file mode 100644
index 0000000..9f967b3
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
@@ -0,0 +1,81 @@
+/** @file
+ This protocol provides registering and unregistering services to status code consumers while in DXE MM.
+
+ Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __MM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
+#define __MM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
+
+#define EFI_MM_RSC_HANDLER_PROTOCOL_GUID \
+ { \
+ 0x2ff29fa7, 0x5e80, 0x4ed9, {0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4} \
+ }
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_RSC_HANDLER_CALLBACK)(
+ IN EFI_STATUS_CODE_TYPE CodeType,
+ IN EFI_STATUS_CODE_VALUE Value,
+ IN UINT32 Instance,
+ IN EFI_GUID *CallerId,
+ IN EFI_STATUS_CODE_DATA *Data
+);
+
+/**
+ Register the callback function for ReportStatusCode() notification.
+
+ When this function is called the function pointer is added to an internal list and any future calls to
+ ReportStatusCode() will be forwarded to the Callback function.
+
+ @param[in] Callback A pointer to a function of type EFI_MM_RSC_HANDLER_CALLBACK that is
+ called when a call to ReportStatusCode() occurs.
+
+ @retval EFI_SUCCESS Function was successfully registered.
+ @retval EFI_INVALID_PARAMETER The callback function was NULL.
+ @retval EFI_OUT_OF_RESOURCES The internal buffer ran out of space. No more functions can be
+ registered.
+ @retval EFI_ALREADY_STARTED The function was already registered. It can't be registered again.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_RSC_HANDLER_REGISTER)(
+ IN EFI_MM_RSC_HANDLER_CALLBACK Callback
+);
+
+/**
+ Remove a previously registered callback function from the notification list.
+
+ A callback function must be unregistered before it is deallocated. It is important that any registered
+ callbacks that are not runtime complaint be unregistered when ExitBootServices() is called.
+
+ @param[in] Callback A pointer to a function of type EFI_MM_RSC_HANDLER_CALLBACK that is to be
+ unregistered.
+
+ @retval EFI_SUCCESS The function was successfully unregistered.
+ @retval EFI_INVALID_PARAMETER The callback function was NULL.
+ @retval EFI_NOT_FOUND The callback function was not found to be unregistered.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_RSC_HANDLER_UNREGISTER)(
+ IN EFI_MM_RSC_HANDLER_CALLBACK Callback
+);
+
+typedef struct _EFI_MM_RSC_HANDLER_PROTOCOL {
+ EFI_MM_RSC_HANDLER_REGISTER Register;
+ EFI_MM_RSC_HANDLER_UNREGISTER Unregister;
+} EFI_MM_RSC_HANDLER_PROTOCOL;
+
+extern EFI_GUID gEfiMmRscHandlerProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h b/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
new file mode 100644
index 0000000..7dcb49c
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
@@ -0,0 +1,119 @@
+/** @file
+ MM Standby Button Dispatch Protocol as defined in PI 1.1 Specification
+ Volume 4 Management Mode Core Interface.
+
+ This protocol provides the parent dispatch service for the standby button MMI source generator.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ @par Revision Reference:
+ This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _MM_STANDBY_BUTTON_DISPATCH_H_
+#define _MM_STANDBY_BUTTON_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b } \
+ }
+
+///
+/// Standby Button phases
+///
+typedef enum {
+ EfiStandbyButtonEntry,
+ EfiStandbyButtonExit,
+ EfiStandbyButtonMax
+} EFI_STANDBY_BUTTON_PHASE;
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+ ///
+ /// Describes whether the child handler should be invoked upon the entry to the button
+ /// activation or upon exit.
+ ///
+ EFI_STANDBY_BUTTON_PHASE Phase;
+} EFI_MM_STANDBY_BUTTON_REGISTER_CONTEXT;
+
+typedef struct _EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL;
+
+/**
+ Provides the parent dispatch service for a standby button event.
+
+ This service registers a function (DispatchFunction) which will be called when an MMI is
+ generated because the standby button was pressed or released, as specified by
+ RegisterContext. On return, DispatchHandle contains a unique handle which may be used
+ later to unregister the function using UnRegister().
+ The DispatchFunction will be called with Context set to the same value as was passed into
+ this function in RegisterContext and with CommBuffer and CommBufferSize set to NULL.
+
+ @param[in] This Pointer to the EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when the standby button is pressed or released.
+ @param[in] RegisterContext Pointer to the dispatch function's context. The caller fills in this context
+ before calling the register function to indicate to the register function the
+ standby button MMI source for which the dispatch function should be invoked.
+ @param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The standby button input value
+ is not within valid range.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_STANDBY_BUTTON_REGISTER)(
+ IN CONST EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN EFI_MM_STANDBY_BUTTON_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregisters a child MMI source dispatch function with a parent MM driver.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called when the standby button is pressed or released.
+
+ @param[in] This Pointer to the EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the service to remove.
+
+ @retval EFI_SUCCESS The service has been successfully removed.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_STANDBY_BUTTON_UNREGISTER)(
+ IN CONST EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Interface structure for the MM Standby Button Dispatch Protocol.
+///
+/// This protocol provides the parent dispatch service for the standby
+/// button MMI source generator.
+///
+struct _EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL {
+ EFI_MM_STANDBY_BUTTON_REGISTER Register;
+ EFI_MM_STANDBY_BUTTON_UNREGISTER UnRegister;
+};
+
+extern EFI_GUID gEfiMmStandbyButtonDispatchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmStatusCode.h b/MdePkg/Include/Protocol/MmStatusCode.h
new file mode 100644
index 0000000..d0bfbac
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmStatusCode.h
@@ -0,0 +1,65 @@
+/** @file
+ EFI MM Status Code Protocol as defined in the PI 1.2 specification.
+
+ This protocol provides the basic status code services while in MM.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_STATUS_CODE_H__
+#define _MM_STATUS_CODE_H__
+
+
+#define EFI_MM_STATUS_CODE_PROTOCOL_GUID \
+ { \
+ 0x6afd2b77, 0x98c1, 0x4acd, {0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1} \
+ }
+
+typedef struct _EFI_MM_STATUS_CODE_PROTOCOL EFI_MM_STATUS_CODE_PROTOCOL;
+
+/**
+ Service to emit the status code in MM.
+
+ The EFI_MM_STATUS_CODE_PROTOCOL.ReportStatusCode() function enables a driver
+ to emit a status code while in MM. The reason that there is a separate protocol definition from the
+ DXE variant of this service is that the publisher of this protocol will provide a service that is
+ capability of coexisting with a foreground operational environment, such as an operating system
+ after the termination of boot services.
+
+ @param[in] This Points to this instance of the EFI_MM_STATUS_CODE_PROTOCOL.
+ @param[in] CodeType DIndicates the type of status code being reported.
+ @param[in] Value Describes the current status of a hardware or software entity.
+ @param[in] Instance The enumeration of a hardware or software entity within the system.
+ @param[in] CallerId This optional parameter may be used to identify the caller.
+ @param[in] Data This optional parameter may be used to pass additional data.
+
+ @retval EFI_SUCCESS The function completed successfully.
+ @retval EFI_INVALID_PARAMETER The function should not be completed due to a device error.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_REPORT_STATUS_CODE)(
+ IN CONST EFI_MM_STATUS_CODE_PROTOCOL *This,
+ IN EFI_STATUS_CODE_TYPE CodeType,
+ IN EFI_STATUS_CODE_VALUE Value,
+ IN UINT32 Instance,
+ IN CONST EFI_GUID *CallerId,
+ IN EFI_STATUS_CODE_DATA *Data OPTIONAL
+ );
+
+struct _EFI_MM_STATUS_CODE_PROTOCOL {
+ EFI_MM_REPORT_STATUS_CODE ReportStatusCode;
+};
+
+extern EFI_GUID gEfiMmStatusCodeProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/MmSwDispatch.h b/MdePkg/Include/Protocol/MmSwDispatch.h
new file mode 100644
index 0000000..004c235
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmSwDispatch.h
@@ -0,0 +1,136 @@
+/** @file
+ MM Software Dispatch Protocol introduced from PI 1.2 Specification
+ Volume 4 Management Mode Core Interface.
+
+ This protocol provides the parent dispatch service for a given MMI source generator.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_SW_DISPATCH2_H_
+#define _MM_SW_DISPATCH2_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_SW_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 } \
+ }
+
+///
+/// A particular chipset may not support all possible software MMI input values.
+/// For example, the ICH supports only values 00h to 0FFh. The parent only allows a single
+/// child registration for each SwMmiInputValue.
+///
+typedef struct {
+ UINTN SwMmiInputValue;
+} EFI_MM_SW_REGISTER_CONTEXT;
+
+///
+/// The DispatchFunction will be called with Context set to the same value as was passed into
+/// this function in RegisterContext and with CommBuffer (and CommBufferSize) pointing
+/// to an instance of EFI_MM_SW_CONTEXT indicating the index of the CPU which generated the
+/// software MMI.
+///
+typedef struct {
+ ///
+ /// The 0-based index of the CPU which generated the software MMI.
+ ///
+ UINTN SwMmiCpuIndex;
+ ///
+ /// This value corresponds directly to the CommandPort parameter used in the call to Trigger().
+ ///
+ UINT8 CommandPort;
+ ///
+ /// This value corresponds directly to the DataPort parameter used in the call to Trigger().
+ ///
+ UINT8 DataPort;
+} EFI_MM_SW_CONTEXT;
+
+typedef struct _EFI_MM_SW_DISPATCH_PROTOCOL EFI_MM_SW_DISPATCH_PROTOCOL;
+
+/**
+ Register a child MMI source dispatch function for the specified software MMI.
+
+ This service registers a function (DispatchFunction) which will be called when the software
+ MMI source specified by RegisterContext->SwMmiCpuIndex is detected. On return,
+ DispatchHandle contains a unique handle which may be used later to unregister the function
+ using UnRegister().
+
+ @param[in] This Pointer to the EFI_MM_SW_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when the specified software
+ MMI is generated.
+ @param[in, out] RegisterContext Pointer to the dispatch function's context.
+ The caller fills this context in before calling
+ the register function to indicate to the register
+ function which Software MMI input value the
+ dispatch function should be invoked for.
+ @param[out] DispatchHandle Handle generated by the dispatcher to track the
+ function instance.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_DEVICE_ERROR The SW driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The SW MMI input value
+ is not within a valid range or is already in use.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this
+ child.
+ @retval EFI_OUT_OF_RESOURCES A unique software MMI value could not be assigned
+ for this dispatch.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_SW_REGISTER)(
+ IN CONST EFI_MM_SW_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN OUT EFI_MM_SW_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregister a child MMI source dispatch function for the specified software MMI.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called in response to a software MMI.
+
+ @param[in] This Pointer to the EFI_MM_SW_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of dispatch function to deregister.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully unregistered.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_SW_UNREGISTER)(
+ IN CONST EFI_MM_SW_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+);
+
+///
+/// Interface structure for the MM Software MMI Dispatch Protocol.
+///
+/// The EFI_MM_SW_DISPATCH2_PROTOCOL provides the ability to install child handlers for the
+/// given software. These handlers will respond to software interrupts, and the maximum software
+/// interrupt in the EFI_MM_SW_REGISTER_CONTEXT is denoted by MaximumSwiValue.
+///
+struct _EFI_MM_SW_DISPATCH_PROTOCOL {
+ EFI_MM_SW_REGISTER Register;
+ EFI_MM_SW_UNREGISTER UnRegister;
+ ///
+ /// A read-only field that describes the maximum value that can be used in the
+ /// EFI_MM_SW_DISPATCH_PROTOCOL.Register() service.
+ ///
+ UINTN MaximumSwiValue;
+};
+
+extern EFI_GUID gEfiMmSwDispatchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmSxDispatch.h b/MdePkg/Include/Protocol/MmSxDispatch.h
new file mode 100644
index 0000000..af63389
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmSxDispatch.h
@@ -0,0 +1,135 @@
+/** @file
+ MM Sx Dispatch Protocol as defined in PI 1.2 Specification
+ Volume 4 Management Mode Core Interface.
+
+ Provides the parent dispatch service for a given Sx-state source generator.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _MM_SX_DISPATCH_H_
+#define _MM_SX_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_SX_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d } \
+ }
+
+///
+/// Sleep states S0-S5
+///
+typedef enum {
+ SxS0,
+ SxS1,
+ SxS2,
+ SxS3,
+ SxS4,
+ SxS5,
+ EfiMaximumSleepType
+} EFI_SLEEP_TYPE;
+
+///
+/// Sleep state phase: entry or exit
+///
+typedef enum {
+ SxEntry,
+ SxExit,
+ EfiMaximumPhase
+} EFI_SLEEP_PHASE;
+
+///
+/// The dispatch function's context
+///
+typedef struct {
+ EFI_SLEEP_TYPE Type;
+ EFI_SLEEP_PHASE Phase;
+} EFI_MM_SX_REGISTER_CONTEXT;
+
+typedef struct _EFI_MM_SX_DISPATCH_PROTOCOL EFI_MM_SX_DISPATCH_PROTOCOL;
+
+/**
+ Provides the parent dispatch service for a given Sx source generator.
+
+ This service registers a function (DispatchFunction) which will be called when the sleep state
+ event specified by RegisterContext is detected. On return, DispatchHandle contains a
+ unique handle which may be used later to unregister the function using UnRegister().
+ The DispatchFunction will be called with Context set to the same value as was passed into
+ this function in RegisterContext and with CommBuffer and CommBufferSize set to
+ NULL and 0 respectively.
+
+ @param[in] This Pointer to the EFI_MM_SX_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when the specified sleep state event occurs.
+ @param[in] RegisterContext Pointer to the dispatch function's context.
+ The caller fills this context in before calling
+ the register function to indicate to the register
+ function which Sx state type and phase the caller
+ wishes to be called back on. For this intertace,
+ the Sx driver will call the registered handlers for
+ all Sx type and phases, so the Sx state handler(s)
+ must check the Type and Phase field of the Dispatch
+ context and act accordingly.
+ @param[out] DispatchHandle Handle of dispatch function, for when interfacing
+ with the parent Sx state MM driver.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_UNSUPPORTED The Sx driver or hardware does not support that
+ Sx Type/Phase.
+ @retval EFI_DEVICE_ERROR The Sx driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. Type & Phase are not
+ within valid range.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this
+ child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_SX_REGISTER)(
+ IN CONST EFI_MM_SX_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN CONST EFI_MM_SX_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregisters an Sx-state service.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called in response to sleep event.
+
+ @param[in] This Pointer to the EFI_MM_SX_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the service to remove.
+
+ @retval EFI_SUCCESS The service has been successfully removed.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_SX_UNREGISTER)(
+ IN CONST EFI_MM_SX_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Interface structure for the MM Sx Dispatch Protocol
+///
+/// The EFI_MM_SX_DISPATCH_PROTOCOL provides the ability to install child handlers to
+/// respond to sleep state related events.
+///
+struct _EFI_MM_SX_DISPATCH_PROTOCOL {
+ EFI_MM_SX_REGISTER Register;
+ EFI_MM_SX_UNREGISTER UnRegister;
+};
+
+extern EFI_GUID gEfiMmSxDispatchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MmUsbDispatch.h b/MdePkg/Include/Protocol/MmUsbDispatch.h
new file mode 100644
index 0000000..0b4fabe
--- /dev/null
+++ b/MdePkg/Include/Protocol/MmUsbDispatch.h
@@ -0,0 +1,130 @@
+/** @file
+ MM USB Dispatch Protocol as defined in PI 1.1 Specification
+ Volume 4 Management Mode Core Interface.
+
+ Provides the parent dispatch service for the USB MMI source generator.
+
+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ @par Revision Reference:
+ This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _MM_USB_DISPATCH_H_
+#define _MM_USB_DISPATCH_H_
+
+#include <Pi/PiMmCis.h>
+
+#define EFI_MM_USB_DISPATCH_PROTOCOL_GUID \
+ { \
+ 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 } \
+ }
+
+///
+/// USB MMI event types
+///
+typedef enum {
+ UsbLegacy,
+ UsbWake
+} EFI_USB_MMI_TYPE;
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+ ///
+ /// Describes whether this child handler will be invoked in response to a USB legacy
+ /// emulation event, such as port-trap on the PS/2* keyboard control registers, or to a
+ /// USB wake event, such as resumption from a sleep state.
+ ///
+ EFI_USB_MMI_TYPE Type;
+ ///
+ /// The device path is part of the context structure and describes the location of the
+ /// particular USB host controller in the system for which this register event will occur.
+ /// This location is important because of the possible integration of several USB host
+ /// controllers in a system.
+ ///
+ EFI_DEVICE_PATH_PROTOCOL *Device;
+} EFI_MM_USB_REGISTER_CONTEXT;
+
+typedef struct _EFI_MM_USB_DISPATCH_PROTOCOL EFI_MM_USB_DISPATCH_PROTOCOL;
+
+/**
+ Provides the parent dispatch service for the USB MMI source generator.
+
+ This service registers a function (DispatchFunction) which will be called when the USB-
+ related MMI specified by RegisterContext has occurred. On return, DispatchHandle
+ contains a unique handle which may be used later to unregister the function using UnRegister().
+ The DispatchFunction will be called with Context set to the same value as was passed into
+ this function in RegisterContext and with CommBuffer containing NULL and
+ CommBufferSize containing zero.
+
+ @param[in] This Pointer to the EFI_MM_USB_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchFunction Function to register for handler when a USB-related MMI occurs.
+ @param[in] RegisterContext Pointer to the dispatch function's context.
+ The caller fills this context in before calling
+ the register function to indicate to the register
+ function the USB MMI types for which the dispatch
+ function should be invoked.
+ @param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ registered and the MMI source has been enabled.
+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI source.
+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The USB MMI type
+ is not within valid range.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system or MM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_USB_REGISTER)(
+ IN CONST EFI_MM_USB_DISPATCH_PROTOCOL *This,
+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
+ IN CONST EFI_MM_USB_REGISTER_CONTEXT *RegisterContext,
+ OUT EFI_HANDLE *DispatchHandle
+ );
+
+/**
+ Unregisters a USB service.
+
+ This service removes the handler associated with DispatchHandle so that it will no longer be
+ called when the USB event occurs.
+
+ @param[in] This Pointer to the EFI_MM_USB_DISPATCH_PROTOCOL instance.
+ @param[in] DispatchHandle Handle of the service to remove.
+
+ @retval EFI_SUCCESS The dispatch function has been successfully
+ unregistered and the MMI source has been disabled
+ if there are no other registered child dispatch
+ functions for this MMI source.
+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MM_USB_UNREGISTER)(
+ IN CONST EFI_MM_USB_DISPATCH_PROTOCOL *This,
+ IN EFI_HANDLE DispatchHandle
+ );
+
+///
+/// Interface structure for the MM USB MMI Dispatch Protocol
+///
+/// This protocol provides the parent dispatch service for the USB MMI source generator.
+///
+struct _EFI_MM_USB_DISPATCH_PROTOCOL {
+ EFI_MM_USB_REGISTER Register;
+ EFI_MM_USB_UNREGISTER UnRegister;
+};
+
+extern EFI_GUID gEfiMmUsbDispatchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/MdePkg.dec b/MdePkg/MdePkg.dec
index f54b056..ace4df3 100644
--- a/MdePkg/MdePkg.dec
+++ b/MdePkg/MdePkg.dec
@@ -1033,6 +1033,9 @@
## Include/Protocol/SmmReportStatusCodeHandler.h
gEfiSmmRscHandlerProtocolGuid = { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }}
+ ## Include/Protocol/MmReportStatusCodeHandler.h
+ gEfiMmRscHandlerProtocolGuid = { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }}
+
## Include/Protocol/AcpiSystemDescriptionTable.h
gEfiAcpiSdtProtocolGuid = { 0xeb97088e, 0xcfdf, 0x49c6, { 0xbe, 0x4b, 0xd9, 0x6, 0xa5, 0xb2, 0xe, 0x86 }}
@@ -1042,60 +1045,117 @@
## Include/Protocol/SmmCpuIo2.h
gEfiSmmCpuIo2ProtocolGuid = { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95, 0x5d, 0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }}
+ ## Include/Protocol/MmCpuIo.h
+ gEfiMmCpuIoProtocolGuid = { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95, 0x5d, 0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }}
+
## Include/Protocol/SmmBase2.h
gEfiSmmBase2ProtocolGuid = { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }}
+ ## Include/Protocol/MmBase.h
+ gEfiMmBaseProtocolGuid = { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }}
+
## Include/Protocol/SmmAccess2.h
gEfiSmmAccess2ProtocolGuid = { 0xc2702b74, 0x800c, 0x4131, { 0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }}
+ ## Include/Protocol/MmAccess.h
+ gEfiMmAccessProtocolGuid = { 0xc2702b74, 0x800c, 0x4131, { 0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }}
+
## Include/Protocol/SmmControl2.h
gEfiSmmControl2ProtocolGuid = { 0x843dc720, 0xab1e, 0x42cb, { 0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}}
+ ## Include/Protocol/MmControl.h
+ gEfiMmControlProtocolGuid = { 0x843dc720, 0xab1e, 0x42cb, { 0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}}
+
## Include/Protocol/SmmConfiguration.h
gEfiSmmConfigurationProtocolGuid= { 0x26eeb3de, 0xb689, 0x492e, { 0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }}
+ ## Include/Protocol/MmConfiguration.h
+ gEfiMmConfigurationProtocolGuid= { 0x26eeb3de, 0xb689, 0x492e, { 0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }}
+
## Include/Protocol/SmmReadyToLock.h
gEfiSmmReadyToLockProtocolGuid = { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }}
+ ## Include/Protocol/MmReadyToLock.h
+ gEfiMmReadyToLockProtocolGuid = { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }}
+
## Include/Protocol/DxeSmmReadyToLock.h
gEfiDxeSmmReadyToLockProtocolGuid = { 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }}
+ ## Include/Protocol/DxeMmReadyToLock.h
+ gEfiDxeMmReadyToLockProtocolGuid = { 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }}
+
## Include/Protocol/SmmCommunication.h
gEfiSmmCommunicationProtocolGuid = { 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }}
+ ## Include/Protocol/MmCommunication.h
+ gEfiMmCommunicationProtocolGuid = { 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }}
+
## Include/Protocol/SmmStatusCode.h
gEfiSmmStatusCodeProtocolGuid = { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}}
+ ## Include/Protocol/MmStatusCode.h
+ gEfiMmStatusCodeProtocolGuid = { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}}
+
## Include/Protocol/SmmCpu.h
gEfiSmmCpuProtocolGuid = { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }}
+ ## Include/Protocol/MmCpu.h
+ gEfiMmCpuProtocolGuid = { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }}
+
## Include/Protocol/SmmPciRootBridgeIo.h
gEfiSmmPciRootBridgeIoProtocolGuid = { 0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }}
+ ## Include/Protocol/MmPciRootBridgeIo.h
+ gEfiMmPciRootBridgeIoProtocolGuid = { 0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }}
+
## Include/Protocol/SmmSwDispatch2.h
gEfiSmmSwDispatch2ProtocolGuid = { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }}
+ ## Include/Protocol/MmSwDispatch.h
+ gEfiMmSwDispatchProtocolGuid = { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }}
+
## Include/Protocol/SmmSxDispatch2.h
gEfiSmmSxDispatch2ProtocolGuid = { 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }}
+ ## Include/Protocol/MmSxDispatch.h
+ gEfiMmSxDispatchProtocolGuid = { 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }}
+
## Include/Protocol/SmmPeriodicTimerDispatch2.h
gEfiSmmPeriodicTimerDispatch2ProtocolGuid = { 0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }}
+ ## Include/Protocol/MmPeriodicTimerDispatch.h
+ gEfiMmPeriodicTimerDispatchProtocolGuid = { 0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }}
+
## Include/Protocol/SmmUsbDispatch2.h
gEfiSmmUsbDispatch2ProtocolGuid = { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }}
+ ## Include/Protocol/MmUsbDispatch.h
+ gEfiMmUsbDispatchProtocolGuid = { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }}
+
## Include/Protocol/SmmGpiDispatch2.h
gEfiSmmGpiDispatch2ProtocolGuid = { 0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }}
+ ## Include/Protocol/MmGpiDispatch.h
+ gEfiMmGpiDispatchProtocolGuid = { 0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }}
+
## Include/Protocol/SmmStandbyButtonDispatch2.h
gEfiSmmStandbyButtonDispatch2ProtocolGuid = { 0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }}
+ ## Include/Protocol/MmStandbyButtonDispatch.h
+ gEfiMmStandbyButtonDispatchProtocolGuid = { 0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }}
+
## Include/Protocol/SmmPowerButtonDispatch2.h
gEfiSmmPowerButtonDispatch2ProtocolGuid = { 0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }}
+ ## Include/Protocol/MmPowerButtonDispatch.h
+ gEfiMmPowerButtonDispatchProtocolGuid = { 0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }}
+
## Include/Protocol/SmmIoTrapDispatch2.h
gEfiSmmIoTrapDispatch2ProtocolGuid = { 0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }}
+ ## Include/Protocol/MmIoTrapDispatch.h
+ gEfiMmIoTrapDispatchProtocolGuid = { 0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }}
+
## Include/Protocol/PiPcd.h
gEfiPcdProtocolGuid = { 0x13a3f0f6, 0x264a, 0x3ef0, { 0xf2, 0xe0, 0xde, 0xc5, 0x12, 0x34, 0x2f, 0x34 } }
@@ -1141,6 +1201,9 @@
## Include/Protocol/SmmEndOfDxe.h
gEfiSmmEndOfDxeProtocolGuid = { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }}
+ ## Include/Protocol/MmEndOfDxe.h
+ gEfiMmEndOfDxeProtocolGuid = { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }}
+
## Include/Protocol/IsaHc.h
gEfiIsaHcProtocolGuid = { 0xbcdaf080, 0x1bde, 0x4e22, {0xae, 0x6a, 0x43, 0x54, 0x1e, 0x12, 0x8e, 0xc4 } }
gEfiIsaHcServiceBindingProtocolGuid = { 0xfad7933a, 0x6c21, 0x4234, {0xa4, 0x34, 0x0a, 0x8a, 0x0d, 0x2b, 0x07, 0x81 } }
--
2.7.0.windows.1
_______________________________________________
edk2-devel mailing list
edk2-devel@lists.01.org
https://lists.01.org/mailman/listinfo/edk2-devel
Eric:
I have two comments.
1) New ppi/protocol should be placed below PI1.6 comment in MdePkg.dec
2) MdePkg\Include\Pi\PiMmCis.h still has SMM word in description. It should use MM instead of SMM.
Thanks
Liming
>-----Original Message-----
>From: Dong, Eric
>Sent: Monday, August 14, 2017 4:33 PM
>To: edk2-devel@lists.01.org
>Cc: Kinney, Michael D <michael.d.kinney@intel.com>; Gao, Liming
><liming.gao@intel.com>
>Subject: [Patch 1/2] MdePkg: Add new definitions for Management Mode.
>
>In PI 1.5 version, system management mode name(SMM) has been changed
>to Management Mode(MM). It impacts the current code which still use
>SMM/Smram/SMI keywords. This patch add new definition which use
>MM/MmRam/MMI keywords to follow new spec definitions.
>
>Cc: Michael D Kinney <michael.d.kinney@intel.com>
>Cc: Liming Gao <liming.gao@intel.com>
>Contributed-under: TianoCore Contribution Agreement 1.1
>Signed-off-by: Eric Dong <eric.dong@intel.com>
>---
> MdePkg/Include/Pi/PiMmCis.h | 350 +++++++++++++++++++++
> MdePkg/Include/PiMm.h | 25 ++
> MdePkg/Include/Protocol/DxeMmReadyToLock.h | 41 +++
> MdePkg/Include/Protocol/MmAccess.h | 133 ++++++++
> MdePkg/Include/Protocol/MmBase.h | 87 +++++
> MdePkg/Include/Protocol/MmCommunication.h | 83 +++++
> MdePkg/Include/Protocol/MmConfiguration.h | 86 +++++
> MdePkg/Include/Protocol/MmControl.h | 106 +++++++
> MdePkg/Include/Protocol/MmCpu.h | 247 +++++++++++++++
> MdePkg/Include/Protocol/MmCpuIo.h | 96 ++++++
> MdePkg/Include/Protocol/MmEndOfDxe.h | 33 ++
> MdePkg/Include/Protocol/MmGpiDispatch.h | 125 ++++++++
> MdePkg/Include/Protocol/MmIoTrapDispatch.h | 136 ++++++++
> MdePkg/Include/Protocol/MmPciRootBridgeIo.h | 37 +++
> MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h | 170 ++++++++++
> MdePkg/Include/Protocol/MmPowerButtonDispatch.h | 117 +++++++
> MdePkg/Include/Protocol/MmReadyToLock.h | 35 +++
> .../Include/Protocol/MmReportStatusCodeHandler.h | 81 +++++
> MdePkg/Include/Protocol/MmStandbyButtonDispatch.h | 119 +++++++
> MdePkg/Include/Protocol/MmStatusCode.h | 65 ++++
> MdePkg/Include/Protocol/MmSwDispatch.h | 136 ++++++++
> MdePkg/Include/Protocol/MmSxDispatch.h | 135 ++++++++
> MdePkg/Include/Protocol/MmUsbDispatch.h | 130 ++++++++
> MdePkg/MdePkg.dec | 63 ++++
> 24 files changed, 2636 insertions(+)
> create mode 100644 MdePkg/Include/Pi/PiMmCis.h
> create mode 100644 MdePkg/Include/PiMm.h
> create mode 100644 MdePkg/Include/Protocol/DxeMmReadyToLock.h
> create mode 100644 MdePkg/Include/Protocol/MmAccess.h
> create mode 100644 MdePkg/Include/Protocol/MmBase.h
> create mode 100644 MdePkg/Include/Protocol/MmCommunication.h
> create mode 100644 MdePkg/Include/Protocol/MmConfiguration.h
> create mode 100644 MdePkg/Include/Protocol/MmControl.h
> create mode 100644 MdePkg/Include/Protocol/MmCpu.h
> create mode 100644 MdePkg/Include/Protocol/MmCpuIo.h
> create mode 100644 MdePkg/Include/Protocol/MmEndOfDxe.h
> create mode 100644 MdePkg/Include/Protocol/MmGpiDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmIoTrapDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmPciRootBridgeIo.h
> create mode 100644 MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmPowerButtonDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmReadyToLock.h
> create mode 100644
>MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
> create mode 100644 MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmStatusCode.h
> create mode 100644 MdePkg/Include/Protocol/MmSwDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmSxDispatch.h
> create mode 100644 MdePkg/Include/Protocol/MmUsbDispatch.h
>
>diff --git a/MdePkg/Include/Pi/PiMmCis.h b/MdePkg/Include/Pi/PiMmCis.h
>new file mode 100644
>index 0000000..6f41fa9
>--- /dev/null
>+++ b/MdePkg/Include/Pi/PiMmCis.h
>@@ -0,0 +1,350 @@
>+/** @file
>+ Common definitions in the Platform Initialization Specification version 1.6
>+ VOLUME 4 Management Mode Core Interface version.
>+
>+ Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _PI_MMCIS_H_
>+#define _PI_MMCIS_H_
>+
>+#include <Protocol/MmCpuIo.h>
>+
>+typedef struct _EFI_MM_SYSTEM_TABLE EFI_MM_SYSTEM_TABLE;
>+
>+///
>+/// The Management Mode System Table (MMST) signature
>+///
>+#define MM_MMST_SIGNATURE SIGNATURE_32 ('S', 'M', 'S', 'T')
>+///
>+/// The Management Mode System Table (MMST) revision is 1.6
>+///
>+#define MM_SPECIFICATION_MAJOR_REVISION 1
>+#define MM_SPECIFICATION_MINOR_REVISION 60
>+#define EFI_MM_SYSTEM_TABLE_REVISION
>((MM_SPECIFICATION_MAJOR_REVISION<<16) |
>(MM_SPECIFICATION_MINOR_REVISION))
>+
>+/**
>+ Adds, updates, or removes a configuration table entry from the
>Management Mode System Table.
>+
>+ The MmInstallConfigurationTable() function is used to maintain the list
>+ of configuration tables that are stored in the Management Mode System
>+ Table. The list is stored as an array of (GUID, Pointer) pairs. The list
>+ must be allocated from pool memory with PoolType set to
>EfiRuntimeServicesData.
>+
>+ @param[in] SystemTable A pointer to the MM System Table (MMST).
>+ @param[in] Guid A pointer to the GUID for the entry to add, update,
>or remove.
>+ @param[in] Table A pointer to the buffer of the table to add.
>+ @param[in] TableSize The size of the table to install.
>+
>+ @retval EFI_SUCCESS The (Guid, Table) pair was added, updated, or
>removed.
>+ @retval EFI_INVALID_PARAMETER Guid is not valid.
>+ @retval EFI_NOT_FOUND An attempt was made to delete a non-
>existent entry.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory available
>to complete the operation.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_INSTALL_CONFIGURATION_TABLE)(
>+ IN CONST EFI_MM_SYSTEM_TABLE *SystemTable,
>+ IN CONST EFI_GUID *Guid,
>+ IN VOID *Table,
>+ IN UINTN TableSize
>+ );
>+
>+/**
>+ This service lets the caller to get one distinct application processor (AP) to
>execute
>+ a caller-provided code stream while in MM.
>+
>+ @param[in] Procedure A pointer to the code stream to be run on the
>designated
>+ AP of the system.
>+ @param[in] CpuNumber The zero-based index of the processor
>number of the AP
>+ on which the code stream is supposed to run.
>+ @param[in,out] ProcArguments Allows the caller to pass a list of
>parameters to the code
>+ that is run by the AP.
>+
>+ @retval EFI_SUCCESS The call was successful and the return
>parameters are valid.
>+ @retval EFI_INVALID_PARAMETER The input arguments are out of range.
>+ @retval EFI_INVALID_PARAMETER The CPU requested is not available on
>this SMI invocation.
>+ @retval EFI_INVALID_PARAMETER The CPU cannot support an additional
>service invocation.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_STARTUP_THIS_AP)(
>+ IN EFI_AP_PROCEDURE Procedure,
>+ IN UINTN CpuNumber,
>+ IN OUT VOID *ProcArguments OPTIONAL
>+ );
>+
>+/**
>+ Function prototype for protocol install notification.
>+
>+ @param[in] Protocol Points to the protocol's unique identifier.
>+ @param[in] Interface Points to the interface instance.
>+ @param[in] Handle The handle on which the interface was installed.
>+
>+ @return Status Code
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_NOTIFY_FN)(
>+ IN CONST EFI_GUID *Protocol,
>+ IN VOID *Interface,
>+ IN EFI_HANDLE Handle
>+ );
>+
>+/**
>+ Register a callback function be called when a particular protocol interface is
>installed.
>+
>+ The MmRegisterProtocolNotify() function creates a registration Function
>that is to be
>+ called whenever a protocol interface is installed for Protocol by
>+ MmInstallProtocolInterface().
>+ If Function == NULL and Registration is an existing registration, then the
>callback is unhooked.
>+
>+ @param[in] Protocol The unique ID of the protocol for which the event
>is to be registered.
>+ @param[in] Function Points to the notification function.
>+ @param[out] Registration A pointer to a memory location to receive the
>registration value.
>+
>+ @retval EFI_SUCCESS Successfully returned the registration record
>+ that has been added or unhooked.
>+ @retval EFI_INVALID_PARAMETER Protocol is NULL or Registration is NULL.
>+ @retval EFI_OUT_OF_RESOURCES Not enough memory resource to finish
>the request.
>+ @retval EFI_NOT_FOUND If the registration is not found when Function
>== NULL.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_REGISTER_PROTOCOL_NOTIFY)(
>+ IN CONST EFI_GUID *Protocol,
>+ IN EFI_MM_NOTIFY_FN Function,
>+ OUT VOID **Registration
>+ );
>+
>+/**
>+ Manage MMI of a particular type.
>+
>+ @param[in] HandlerType Points to the handler type or NULL for root
>MMI handlers.
>+ @param[in] Context Points to an optional context buffer.
>+ @param[in,out] CommBuffer Points to the optional communication
>buffer.
>+ @param[in,out] CommBufferSize Points to the size of the optional
>communication buffer.
>+
>+ @retval EFI_WARN_INTERRUPT_SOURCE_PENDING Interrupt source was
>processed successfully but not quiesced.
>+ @retval EFI_INTERRUPT_PENDING One or more SMI sources could
>not be quiesced.
>+ @retval EFI_NOT_FOUND Interrupt source was not handled or
>quiesced.
>+ @retval EFI_SUCCESS Interrupt source was handled and
>quiesced.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_INTERRUPT_MANAGE)(
>+ IN CONST EFI_GUID *HandlerType,
>+ IN CONST VOID *Context OPTIONAL,
>+ IN OUT VOID *CommBuffer OPTIONAL,
>+ IN OUT UINTN *CommBufferSize OPTIONAL
>+ );
>+
>+/**
>+ Main entry point for an MM handler dispatch or communicate-based
>callback.
>+
>+ @param[in] DispatchHandle The unique handle assigned to this handler
>by MmiHandlerRegister().
>+ @param[in] Context Points to an optional handler context which was
>specified when the
>+ handler was registered.
>+ @param[in,out] CommBuffer A pointer to a collection of data in memory
>that will
>+ be conveyed from a non-MM environment into an MM
>environment.
>+ @param[in,out] CommBufferSize The size of the CommBuffer.
>+
>+ @retval EFI_SUCCESS The interrupt was handled and quiesced.
>No other handlers
>+ should still be called.
>+ @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has
>been quiesced but other handlers should
>+ still be called.
>+ @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still
>pending and other handlers should still
>+ be called.
>+ @retval EFI_INTERRUPT_PENDING The interrupt could not be
>quiesced.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_HANDLER_ENTRY_POINT)(
>+ IN EFI_HANDLE DispatchHandle,
>+ IN CONST VOID *Context OPTIONAL,
>+ IN OUT VOID *CommBuffer OPTIONAL,
>+ IN OUT UINTN *CommBufferSize OPTIONAL
>+ );
>+
>+/**
>+ Registers a handler to execute within MM.
>+
>+ @param[in] Handler Handler service function pointer.
>+ @param[in] HandlerType Points to the handler type or NULL for root
>MMI handlers.
>+ @param[out] DispatchHandle On return, contains a unique handle which
>can be used to later
>+ unregister the handler function.
>+
>+ @retval EFI_SUCCESS MMI handler added successfully.
>+ @retval EFI_INVALID_PARAMETER Handler is NULL or DispatchHandle is
>NULL.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_INTERRUPT_REGISTER)(
>+ IN EFI_MM_HANDLER_ENTRY_POINT Handler,
>+ IN CONST EFI_GUID *HandlerType OPTIONAL,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregister a handler in MM.
>+
>+ @param[in] DispatchHandle The handle that was specified when the
>handler was registered.
>+
>+ @retval EFI_SUCCESS Handler function was successfully unregistered.
>+ @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid
>handle.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_INTERRUPT_UNREGISTER)(
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Processor information and functionality needed by MM Foundation.
>+///
>+typedef struct _EFI_MM_ENTRY_CONTEXT {
>+ EFI_MM_STARTUP_THIS_AP MmStartupThisAp;
>+ ///
>+ /// A number between zero and the NumberOfCpus field. This field
>designates which
>+ /// processor is executing the SMM Foundation.
>+ ///
>+ UINTN CurrentlyExecutingCpu;
>+ ///
>+ /// The number of possible processors in the platform. This is a 1 based
>+ /// counter. This does not indicate the number of processors that entered
>SMM.
>+ ///
>+ UINTN NumberOfCpus;
>+ ///
>+ /// Points to an array, where each element describes the number of bytes
>in the
>+ /// corresponding save state specified by CpuSaveState. There are always
>+ /// NumberOfCpus entries in the array.
>+ ///
>+ UINTN *CpuSaveStateSize;
>+ ///
>+ /// Points to an array, where each element is a pointer to a CPU save state.
>The
>+ /// corresponding element in CpuSaveStateSize specifies the number of
>bytes in the
>+ /// save state area. There are always NumberOfCpus entries in the array.
>+ ///
>+ VOID **CpuSaveState;
>+} EFI_MM_ENTRY_CONTEXT;
>+
>+/**
>+ This function is the main entry point to the MM Foundation.
>+
>+ @param[in] MmEntryContext Processor information and functionality
>needed by MM Foundation.
>+**/
>+typedef
>+VOID
>+(EFIAPI *EFI_MM_ENTRY_POINT)(
>+ IN CONST EFI_MM_ENTRY_CONTEXT *MmEntryContext
>+ );
>+
>+///
>+/// Management Mode System Table (MMST)
>+///
>+/// The Management Mode System Table (MMST) is a table that contains a
>collection of common
>+/// services for managing MMRAM allocation and providing basic I/O services.
>These services are
>+/// intended for both preboot and runtime usage.
>+///
>+struct _EFI_MM_SYSTEM_TABLE {
>+ ///
>+ /// The table header for the SMST.
>+ ///
>+ EFI_TABLE_HEADER Hdr;
>+ ///
>+ /// A pointer to a NULL-terminated Unicode string containing the vendor
>name.
>+ /// It is permissible for this pointer to be NULL.
>+ ///
>+ CHAR16 *MmFirmwareVendor;
>+ ///
>+ /// The particular revision of the firmware.
>+ ///
>+ UINT32 MmFirmwareRevision;
>+
>+ EFI_MM_INSTALL_CONFIGURATION_TABLE MmInstallConfigurationTable;
>+
>+ ///
>+ /// I/O Service
>+ ///
>+ EFI_MM_CPU_IO_PROTOCOL MmIo;
>+
>+ ///
>+ /// Runtime memory services
>+ ///
>+ EFI_ALLOCATE_POOL MmAllocatePool;
>+ EFI_FREE_POOL MmFreePool;
>+ EFI_ALLOCATE_PAGES MmAllocatePages;
>+ EFI_FREE_PAGES MmFreePages;
>+
>+ ///
>+ /// MP service
>+ ///
>+ EFI_MM_STARTUP_THIS_AP MmStartupThisAp;
>+
>+ ///
>+ /// CPU information records
>+ ///
>+
>+ ///
>+ /// A number between zero and and the NumberOfCpus field. This field
>designates
>+ /// which processor is executing the SMM infrastructure.
>+ ///
>+ UINTN CurrentlyExecutingCpu;
>+ ///
>+ /// The number of possible processors in the platform. This is a 1 based
>counter.
>+ ///
>+ UINTN NumberOfCpus;
>+ ///
>+ /// Points to an array, where each element describes the number of bytes
>in the
>+ /// corresponding save state specified by CpuSaveState. There are always
>+ /// NumberOfCpus entries in the array.
>+ ///
>+ UINTN *CpuSaveStateSize;
>+ ///
>+ /// Points to an array, where each element is a pointer to a CPU save state.
>The
>+ /// corresponding element in CpuSaveStateSize specifies the number of
>bytes in the
>+ /// save state area. There are always NumberOfCpus entries in the array.
>+ ///
>+ VOID **CpuSaveState;
>+
>+ ///
>+ /// Extensibility table
>+ ///
>+
>+ ///
>+ /// The number of UEFI Configuration Tables in the buffer
>SmmConfigurationTable.
>+ ///
>+ UINTN NumberOfTableEntries;
>+ ///
>+ /// A pointer to the UEFI Configuration Tables. The number of entries in the
>table is
>+ /// NumberOfTableEntries.
>+ ///
>+ EFI_CONFIGURATION_TABLE *MmConfigurationTable;
>+
>+ ///
>+ /// Protocol services
>+ ///
>+ EFI_INSTALL_PROTOCOL_INTERFACE MmInstallProtocolInterface;
>+ EFI_UNINSTALL_PROTOCOL_INTERFACE MmUninstallProtocolInterface;
>+ EFI_HANDLE_PROTOCOL MmHandleProtocol;
>+ EFI_MM_REGISTER_PROTOCOL_NOTIFY MmRegisterProtocolNotify;
>+ EFI_LOCATE_HANDLE MmLocateHandle;
>+ EFI_LOCATE_PROTOCOL MmLocateProtocol;
>+
>+ ///
>+ /// MMI Management functions
>+ ///
>+ EFI_MM_INTERRUPT_MANAGE MmiManage;
>+ EFI_MM_INTERRUPT_REGISTER MmiHandlerRegister;
>+ EFI_MM_INTERRUPT_UNREGISTER MmiHandlerUnRegister;
>+};
>+
>+#endif
>diff --git a/MdePkg/Include/PiMm.h b/MdePkg/Include/PiMm.h
>new file mode 100644
>index 0000000..fdb7d27
>--- /dev/null
>+++ b/MdePkg/Include/PiMm.h
>@@ -0,0 +1,25 @@
>+/** @file
>+
>+ Root include file for Mde Package MM modules.
>+
>+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+This program and the accompanying materials are licensed and made
>available under
>+the terms and conditions of the BSD License that accompanies this
>distribution.
>+The full text of the license may be found at
>+http://opensource.org/licenses/bsd-license.php.
>+
>+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef __PI_MM_H__
>+#define __PI_MM_H__
>+
>+#include <Uefi/UefiBaseType.h>
>+#include <Uefi/UefiSpec.h>
>+
>+#include <Pi/PiMmCis.h>
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/DxeMmReadyToLock.h
>b/MdePkg/Include/Protocol/DxeMmReadyToLock.h
>new file mode 100644
>index 0000000..9101101
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/DxeMmReadyToLock.h
>@@ -0,0 +1,41 @@
>+/** @file
>+ DXE MM Ready To Lock protocol introduced in the PI 1.2 specification.
>+
>+ According to PI 1.4a specification, this UEFI protocol indicates that
>+ resources and services that should not be used by the third party code
>+ are about to be locked.
>+ This protocol is a mandatory protocol published by PI platform code.
>+ This protocol in tandem with the End of DXE Event facilitates transition
>+ of the platform from the environment where all of the components are
>+ under the authority of the platform manufacturer to the environment
>where
>+ third party extensible modules such as UEFI drivers and UEFI applications
>+ are executed. The protocol is published immediately after signaling of the
>+ End of DXE Event. PI modules that need to lock or protect their resources
>+ in anticipation of the invocation of 3rd party extensible modules should
>+ register for notification on installation of this protocol and effect the
>+ appropriate protections in their notification handlers. For example, PI
>+ platform code may choose to use notification handler to lock MM by
>invoking
>+ EFI_MM_ACCESS_PROTOCOL.Lock() function.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _DXE_MM_READY_TO_LOCK_H_
>+#define _DXE_MM_READY_TO_LOCK_H_
>+
>+#define EFI_DXE_MM_READY_TO_LOCK_PROTOCOL_GUID \
>+ { \
>+ 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0,
>0x8e } \
>+ }
>+
>+extern EFI_GUID gEfiDxeMmReadyToLockProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmAccess.h
>b/MdePkg/Include/Protocol/MmAccess.h
>new file mode 100644
>index 0000000..b59c798
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmAccess.h
>@@ -0,0 +1,133 @@
>+/** @file
>+ EFI MM Access Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol is used to control the visibility of the MMRAM on the platform.
>+ It abstracts the location and characteristics of MMRAM. The expectation is
>+ that the north bridge or memory controller would publish this protocol.
>+
>+ The principal functionality found in the memory controller includes the
>following:
>+ - Exposing the MMRAM to all non-MM agents, or the "open" state
>+ - Shrouding the MMRAM to all but the MM agents, or the "closed" state
>+ - Preserving the system integrity, or "locking" the MMRAM, such that the
>settings cannot be
>+ perturbed by either boot service or runtime agents
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_ACCESS_H_
>+#define _MM_ACCESS_H_
>+
>+#define EFI_MM_ACCESS_PROTOCOL_GUID \
>+ { \
>+ 0xc2702b74, 0x800c, 0x4131, {0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4,
>0xac } \
>+ }
>+
>+
>+typedef struct _EFI_MM_ACCESS_PROTOCOL EFI_MM_ACCESS_PROTOCOL;
>+
>+/**
>+ Opens the MMRAM area to be accessible by a boot-service driver.
>+
>+ This function "opens" MMRAM so that it is visible while not inside of MM.
>The function should
>+ return EFI_UNSUPPORTED if the hardware does not support hiding of
>MMRAM. The function
>+ should return EFI_DEVICE_ERROR if the MMRAM configuration is locked.
>+
>+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
>+
>+ @retval EFI_SUCCESS The operation was successful.
>+ @retval EFI_UNSUPPORTED The system does not support opening and
>closing of MMRAM.
>+ @retval EFI_DEVICE_ERROR MMRAM cannot be opened, perhaps because
>it is locked.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_OPEN)(
>+ IN EFI_MM_ACCESS_PROTOCOL *This
>+ );
>+
>+/**
>+ Inhibits access to the MMRAM.
>+
>+ This function "closes" MMRAM so that it is not visible while outside of MM.
>The function should
>+ return EFI_UNSUPPORTED if the hardware does not support hiding of
>MMRAM.
>+
>+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
>+
>+ @retval EFI_SUCCESS The operation was successful.
>+ @retval EFI_UNSUPPORTED The system does not support opening and
>closing of MMRAM.
>+ @retval EFI_DEVICE_ERROR MMRAM cannot be closed.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_CLOSE)(
>+ IN EFI_MM_ACCESS_PROTOCOL *This
>+ );
>+
>+/**
>+ Inhibits access to the MMRAM.
>+
>+ This function prohibits access to the MMRAM region. This function is
>usually implemented such
>+ that it is a write-once operation.
>+
>+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
>+
>+ @retval EFI_SUCCESS The device was successfully locked.
>+ @retval EFI_UNSUPPORTED The system does not support locking of
>MMRAM.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_LOCK)(
>+ IN EFI_MM_ACCESS_PROTOCOL *This
>+ );
>+
>+/**
>+ Queries the memory controller for the possible regions that will support
>MMRAM.
>+
>+ @param[in] This The EFI_MM_ACCESS_PROTOCOL instance.
>+ @param[in,out] MmramMapSize A pointer to the size, in bytes, of the
>MmramMemoryMap buffer.
>+ @param[in,out] MmramMap A pointer to the buffer in which firmware
>places the current memory map.
>+
>+ @retval EFI_SUCCESS The chipset supported the given resource.
>+ @retval EFI_BUFFER_TOO_SMALL The MmramMap parameter was too
>small. The current buffer size
>+ needed to hold the memory map is returned in
>MmramMapSize.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_CAPABILITIES)(
>+ IN CONST EFI_MM_ACCESS_PROTOCOL *This,
>+ IN OUT UINTN *MmramMapSize,
>+ IN OUT EFI_MMRAM_DESCRIPTOR *MmramMap
>+ );
>+
>+///
>+/// EFI MM Access Protocol is used to control the visibility of the MMRAM
>on the platform.
>+/// It abstracts the location and characteristics of MMRAM. The platform
>should report all
>+/// MMRAM via EFI_MM_ACCESS_PROTOCOL. The expectation is that the
>north bridge or memory
>+/// controller would publish this protocol.
>+///
>+struct _EFI_MM_ACCESS_PROTOCOL {
>+ EFI_MM_OPEN Open;
>+ EFI_MM_CLOSE Close;
>+ EFI_MM_LOCK Lock;
>+ EFI_MM_CAPABILITIES GetCapabilities;
>+ ///
>+ /// Indicates the current state of the MMRAM. Set to TRUE if MMRAM is
>locked.
>+ ///
>+ BOOLEAN LockState;
>+ ///
>+ /// Indicates the current state of the MMRAM. Set to TRUE if MMRAM is
>open.
>+ ///
>+ BOOLEAN OpenState;
>+};
>+
>+extern EFI_GUID gEfiMmAccessProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmBase.h
>b/MdePkg/Include/Protocol/MmBase.h
>new file mode 100644
>index 0000000..23c3bf4
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmBase.h
>@@ -0,0 +1,87 @@
>+/** @file
>+ EFI MM Base Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol is utilized by all MM drivers to locate the MM infrastructure
>services and determine
>+ whether the driver is being invoked inside MMRAM or outside of MMRAM.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_BASE_H_
>+#define _MM_BASE_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_BASE_PROTOCOL_GUID \
>+ { \
>+ 0xf4ccbfb7, 0xf6e0, 0x47fd, {0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }
>\
>+ }
>+
>+typedef struct _EFI_MM_BASE_PROTOCOL EFI_MM_BASE_PROTOCOL;
>+
>+/**
>+ Service to indicate whether the driver is currently executing in the MM
>Initialization phase.
>+
>+ This service is used to indicate whether the driver is currently executing in
>the MM Initialization
>+ phase. For MM drivers, this will return TRUE in InMmram while inside the
>driver's entry point and
>+ otherwise FALSE. For combination MM/DXE drivers, this will return FALSE in
>the DXE launch. For the
>+ MM launch, it behaves as an MM driver.
>+
>+ @param[in] This The EFI_MM_BASE_PROTOCOL instance.
>+ @param[out] InMmram Pointer to a Boolean which, on return,
>indicates that the driver is
>+ currently executing inside of MMRAM (TRUE) or outside of
>MMRAM (FALSE).
>+
>+ @retval EFI_SUCCESS The call returned successfully.
>+ @retval EFI_INVALID_PARAMETER InMmram was NULL.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_INSIDE_OUT)(
>+ IN CONST EFI_MM_BASE_PROTOCOL *This,
>+ OUT BOOLEAN *InMmram
>+ )
>+;
>+
>+/**
>+ Returns the location of the Management Mode Service Table (MMST).
>+
>+ This function returns the location of the Management Mode Service Table
>(MMST). The use of the
>+ API is such that a driver can discover the location of the MMST in its entry
>point and then cache it in
>+ some driver global variable so that the MMST can be invoked in subsequent
>handlers.
>+
>+ @param[in] This The EFI_MM_BASE_PROTOCOL instance.
>+ @param[in,out] Mmst On return, points to a pointer to the
>Management Mode Service Table (MMST).
>+
>+ @retval EFI_SUCCESS The operation was successful.
>+ @retval EFI_INVALID_PARAMETER Mmst was invalid.
>+ @retval EFI_UNSUPPORTED Not in MM.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_GET_MMST_LOCATION)(
>+ IN CONST EFI_MM_BASE_PROTOCOL *This,
>+ IN OUT EFI_MM_SYSTEM_TABLE **Mmst
>+ )
>+;
>+
>+///
>+/// EFI MM Base Protocol is utilized by all MM drivers to locate the MM
>infrastructure
>+/// services and determine whether the driver is being invoked inside
>MMRAM or outside of MMRAM.
>+///
>+struct _EFI_MM_BASE_PROTOCOL {
>+ EFI_MM_INSIDE_OUT InMm;
>+ EFI_MM_GET_MMST_LOCATION GetMmstLocation;
>+};
>+
>+extern EFI_GUID gEfiMmBaseProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmCommunication.h
>b/MdePkg/Include/Protocol/MmCommunication.h
>new file mode 100644
>index 0000000..5dbb38e
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmCommunication.h
>@@ -0,0 +1,83 @@
>+/** @file
>+ EFI MM Communication Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol provides a means of communicating between drivers outside
>of MM and MMI
>+ handlers inside of MM.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_COMMUNICATION_H_
>+#define _MM_COMMUNICATION_H_
>+
>+#pragma pack(1)
>+
>+///
>+/// To avoid confusion in interpreting frames, the communication buffer
>should always
>+/// begin with EFI_MM_COMMUNICATE_HEADER
>+///
>+typedef struct {
>+ ///
>+ /// Allows for disambiguation of the message format.
>+ ///
>+ EFI_GUID HeaderGuid;
>+ ///
>+ /// Describes the size of Data (in bytes) and does not include the size of the
>header.
>+ ///
>+ UINTN MessageLength;
>+ ///
>+ /// Designates an array of bytes that is MessageLength in size.
>+ ///
>+ UINT8 Data[1];
>+} EFI_MM_COMMUNICATE_HEADER;
>+
>+#pragma pack()
>+
>+#define EFI_MM_COMMUNICATION_PROTOCOL_GUID \
>+ { \
>+ 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3,
>0x32 } \
>+ }
>+
>+typedef struct _EFI_MM_COMMUNICATION_PROTOCOL
>EFI_MM_COMMUNICATION_PROTOCOL;
>+
>+/**
>+ Communicates with a registered handler.
>+
>+ This function provides a service to send and receive messages from a
>registered UEFI service.
>+
>+ @param[in] This The EFI_MM_COMMUNICATION_PROTOCOL
>instance.
>+ @param[in] CommBuffer A pointer to the buffer to convey into
>MMRAM.
>+ @param[in] CommSize The size of the data buffer being passed in.On
>exit, the size of data
>+ being returned. Zero if the handler does not wish to reply
>with any data.
>+
>+ @retval EFI_SUCCESS The message was successfully posted.
>+ @retval EFI_INVALID_PARAMETER The CommBuffer was NULL.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_COMMUNICATE)(
>+ IN CONST EFI_MM_COMMUNICATION_PROTOCOL *This,
>+ IN OUT VOID *CommBuffer,
>+ IN OUT UINTN *CommSize
>+ );
>+
>+///
>+/// EFI MM Communication Protocol provides runtime services for
>communicating
>+/// between DXE drivers and a registered MMI handler.
>+///
>+struct _EFI_MM_COMMUNICATION_PROTOCOL {
>+ EFI_MM_COMMUNICATE Communicate;
>+};
>+
>+extern EFI_GUID gEfiMmCommunicationProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmConfiguration.h
>b/MdePkg/Include/Protocol/MmConfiguration.h
>new file mode 100644
>index 0000000..aacd96c
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmConfiguration.h
>@@ -0,0 +1,86 @@
>+/** @file
>+ EFI MM Configuration Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol is used to:
>+ 1) report the portions of MMRAM regions which cannot be used for the
>MMRAM heap.
>+ 2) register the MM Foundation entry point with the processor code. The
>entry
>+ point will be invoked by the MM processor entry code.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_CONFIGURATION_H_
>+#define _MM_CONFIGURATION_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_CONFIGURATION_PROTOCOL_GUID \
>+ { \
>+ 0x26eeb3de, 0xb689, 0x492e, {0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b,
>0xa7 } \
>+ }
>+
>+///
>+/// Structure describing a MMRAM region which cannot be used for the
>MMRAM heap.
>+///
>+typedef struct _EFI_MM_RESERVED_MMRAM_REGION {
>+ ///
>+ /// Starting address of the reserved MMRAM area, as it appears while
>MMRAM is open.
>+ /// Ignored if MmramReservedSize is 0.
>+ ///
>+ EFI_PHYSICAL_ADDRESS MmramReservedStart;
>+ ///
>+ /// Number of bytes occupied by the reserved MMRAM area. A size of zero
>indicates the
>+ /// last MMRAM area.
>+ ///
>+ UINT64 MmramReservedSize;
>+} EFI_MM_RESERVED_MMRAM_REGION;
>+
>+typedef struct _EFI_MM_CONFIGURATION_PROTOCOL
>EFI_MM_CONFIGURATION_PROTOCOL;
>+
>+/**
>+ Register the MM Foundation entry point.
>+
>+ This function registers the MM Foundation entry point with the processor
>code. This entry point
>+ will be invoked by the MM Processor entry code.
>+
>+ @param[in] This The EFI_MM_CONFIGURATION_PROTOCOL
>instance.
>+ @param[in] MmEntryPoint MM Foundation entry point.
>+
>+ @retval EFI_SUCCESS Success to register MM Entry Point.
>+ @retval EFI_INVALID_PARAMETER MmEntryPoint is NULL.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_REGISTER_MM_ENTRY)(
>+ IN CONST EFI_MM_CONFIGURATION_PROTOCOL *This,
>+ IN EFI_MM_ENTRY_POINT MmEntryPoint
>+ );
>+
>+///
>+/// The EFI MM Configuration Protocol is a mandatory protocol published by
>a DXE CPU driver to
>+/// indicate which areas within MMRAM are reserved for use by the CPU for
>any purpose,
>+/// such as stack, save state or MM entry point.
>+///
>+/// The RegistermmEntry() function allows the MM IPL DXE driver to register
>the MM
>+/// Foundation entry point with the MM entry vector code.
>+///
>+struct _EFI_MM_CONFIGURATION_PROTOCOL {
>+ ///
>+ /// A pointer to an array MMRAM ranges used by the initial MM entry code.
>+ ///
>+ EFI_MM_RESERVED_MMRAM_REGION *MmramReservedRegions;
>+ EFI_MM_REGISTER_MM_ENTRY RegisterMmEntry;
>+};
>+
>+extern EFI_GUID gEfiMmConfigurationProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmControl.h
>b/MdePkg/Include/Protocol/MmControl.h
>new file mode 100644
>index 0000000..c8672c5
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmControl.h
>@@ -0,0 +1,106 @@
>+/** @file
>+ EFI MM Control Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol is used initiate synchronous MMI activations. This protocol
>could be published by a
>+ processor driver to abstract the MMI IPI or a driver which abstracts the ASIC
>that is supporting the
>+ APM port. Because of the possibility of performing MMI IPI transactions,
>the ability to generate this
>+ event from a platform chipset agent is an optional capability for both IA-32
>and x64-based systems.
>+
>+ The EFI_MM_CONTROL_PROTOCOL is produced by a runtime driver. It
>provides an
>+ abstraction of the platform hardware that generates an MMI. There are
>often I/O ports that, when
>+ accessed, will generate the MMI. Also, the hardware optionally supports
>the periodic generation of
>+ these signals.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_CONTROL_H_
>+#define _MM_CONTROL_H_
>+
>+#include <PiDxe.h>
>+
>+#define EFI_MM_CONTROL_PROTOCOL_GUID \
>+ { \
>+ 0x843dc720, 0xab1e, 0x42cb, {0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}
>\
>+ }
>+
>+typedef struct _EFI_MM_CONTROL_PROTOCOL
>EFI_MM_CONTROL_PROTOCOL;
>+typedef UINTN EFI_MM_PERIOD;
>+
>+/**
>+ Invokes MMI activation from either the preboot or runtime environment.
>+
>+ This function generates an MMI.
>+
>+ @param[in] This The EFI_MM_CONTROL_PROTOCOL instance.
>+ @param[in,out] CommandPort The value written to the command port.
>+ @param[in,out] DataPort The value written to the data port.
>+ @param[in] Periodic Optional mechanism to engender a periodic
>stream.
>+ @param[in] ActivationInterval Optional parameter to repeat at this
>period one
>+ time or, if the Periodic Boolean is set, periodically.
>+
>+ @retval EFI_SUCCESS The MMI/PMI has been engendered.
>+ @retval EFI_DEVICE_ERROR The timing is unsupported.
>+ @retval EFI_INVALID_PARAMETER The activation period is unsupported.
>+ @retval EFI_INVALID_PARAMETER The last periodic activation has not been
>cleared.
>+ @retval EFI_NOT_STARTED The MM base service has not been
>initialized.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_ACTIVATE)(
>+ IN CONST EFI_MM_CONTROL_PROTOCOL *This,
>+ IN OUT UINT8 *CommandPort OPTIONAL,
>+ IN OUT UINT8 *DataPort OPTIONAL,
>+ IN BOOLEAN Periodic OPTIONAL,
>+ IN UINTN ActivationInterval OPTIONAL
>+ );
>+
>+/**
>+ Clears any system state that was created in response to the Trigger() call.
>+
>+ This function acknowledges and causes the deassertion of the MMI
>activation source.
>+
>+ @param[in] This The EFI_MM_CONTROL_PROTOCOL instance.
>+ @param[in] Periodic Optional parameter to repeat at this period one
>time
>+
>+ @retval EFI_SUCCESS The MMI/PMI has been engendered.
>+ @retval EFI_DEVICE_ERROR The source could not be cleared.
>+ @retval EFI_INVALID_PARAMETER The service did not support the Periodic
>input argument.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_DEACTIVATE)(
>+ IN CONST EFI_MM_CONTROL_PROTOCOL *This,
>+ IN BOOLEAN Periodic OPTIONAL
>+ );
>+
>+///
>+/// The EFI_MM_CONTROL_PROTOCOL is produced by a runtime driver. It
>provides an
>+/// abstraction of the platform hardware that generates an MMI. There are
>often I/O ports that, when
>+/// accessed, will generate the MMI. Also, the hardware optionally supports
>the periodic generation of
>+/// these signals.
>+///
>+struct _EFI_MM_CONTROL_PROTOCOL {
>+ EFI_MM_ACTIVATE Trigger;
>+ EFI_MM_DEACTIVATE Clear;
>+ ///
>+ /// Minimum interval at which the platform can set the period. A maximum
>is not
>+ /// specified in that the MM infrastructure code can emulate a maximum
>interval that is
>+ /// greater than the hardware capabilities by using software emulation in
>the MM
>+ /// infrastructure code.
>+ ///
>+ EFI_MM_PERIOD MinimumTriggerPeriod;
>+};
>+
>+extern EFI_GUID gEfiMmControlProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmCpu.h
>b/MdePkg/Include/Protocol/MmCpu.h
>new file mode 100644
>index 0000000..d6ddbcd
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmCpu.h
>@@ -0,0 +1,247 @@
>+/** @file
>+ EFI MM CPU Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol allows MM drivers to access architecture-standard registers
>from any of the CPU
>+ save state areas. In some cases, difference processors provide the same
>information in the save state,
>+ but not in the same format. These so-called pseudo-registers provide this
>information in a standard
>+ format.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_CPU_H_
>+#define _MM_CPU_H_
>+
>+#define EFI_MM_CPU_PROTOCOL_GUID \
>+ { \
>+ 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5,
>0x69 } \
>+ }
>+
>+///
>+/// Save State register index
>+///
>+typedef enum {
>+ ///
>+ /// x86/X64 standard registers
>+ ///
>+ EFI_MM_SAVE_STATE_REGISTER_GDTBASE = 4,
>+ EFI_MM_SAVE_STATE_REGISTER_IDTBASE = 5,
>+ EFI_MM_SAVE_STATE_REGISTER_LDTBASE = 6,
>+ EFI_MM_SAVE_STATE_REGISTER_GDTLIMIT = 7,
>+ EFI_MM_SAVE_STATE_REGISTER_IDTLIMIT = 8,
>+ EFI_MM_SAVE_STATE_REGISTER_LDTLIMIT = 9,
>+ EFI_MM_SAVE_STATE_REGISTER_LDTINFO = 10,
>+ EFI_MM_SAVE_STATE_REGISTER_ES = 20,
>+ EFI_MM_SAVE_STATE_REGISTER_CS = 21,
>+ EFI_MM_SAVE_STATE_REGISTER_SS = 22,
>+ EFI_MM_SAVE_STATE_REGISTER_DS = 23,
>+ EFI_MM_SAVE_STATE_REGISTER_FS = 24,
>+ EFI_MM_SAVE_STATE_REGISTER_GS = 25,
>+ EFI_MM_SAVE_STATE_REGISTER_LDTR_SEL = 26,
>+ EFI_MM_SAVE_STATE_REGISTER_TR_SEL = 27,
>+ EFI_MM_SAVE_STATE_REGISTER_DR7 = 28,
>+ EFI_MM_SAVE_STATE_REGISTER_DR6 = 29,
>+ EFI_MM_SAVE_STATE_REGISTER_R8 = 30,
>+ EFI_MM_SAVE_STATE_REGISTER_R9 = 31,
>+ EFI_MM_SAVE_STATE_REGISTER_R10 = 32,
>+ EFI_MM_SAVE_STATE_REGISTER_R11 = 33,
>+ EFI_MM_SAVE_STATE_REGISTER_R12 = 34,
>+ EFI_MM_SAVE_STATE_REGISTER_R13 = 35,
>+ EFI_MM_SAVE_STATE_REGISTER_R14 = 36,
>+ EFI_MM_SAVE_STATE_REGISTER_R15 = 37,
>+ EFI_MM_SAVE_STATE_REGISTER_RAX = 38,
>+ EFI_MM_SAVE_STATE_REGISTER_RBX = 39,
>+ EFI_MM_SAVE_STATE_REGISTER_RCX = 40,
>+ EFI_MM_SAVE_STATE_REGISTER_RDX = 41,
>+ EFI_MM_SAVE_STATE_REGISTER_RSP = 42,
>+ EFI_MM_SAVE_STATE_REGISTER_RBP = 43,
>+ EFI_MM_SAVE_STATE_REGISTER_RSI = 44,
>+ EFI_MM_SAVE_STATE_REGISTER_RDI = 45,
>+ EFI_MM_SAVE_STATE_REGISTER_RIP = 46,
>+ EFI_MM_SAVE_STATE_REGISTER_RFLAGS = 51,
>+ EFI_MM_SAVE_STATE_REGISTER_CR0 = 52,
>+ EFI_MM_SAVE_STATE_REGISTER_CR3 = 53,
>+ EFI_MM_SAVE_STATE_REGISTER_CR4 = 54,
>+ EFI_MM_SAVE_STATE_REGISTER_FCW = 256,
>+ EFI_MM_SAVE_STATE_REGISTER_FSW = 257,
>+ EFI_MM_SAVE_STATE_REGISTER_FTW = 258,
>+ EFI_MM_SAVE_STATE_REGISTER_OPCODE = 259,
>+ EFI_MM_SAVE_STATE_REGISTER_FP_EIP = 260,
>+ EFI_MM_SAVE_STATE_REGISTER_FP_CS = 261,
>+ EFI_MM_SAVE_STATE_REGISTER_DATAOFFSET = 262,
>+ EFI_MM_SAVE_STATE_REGISTER_FP_DS = 263,
>+ EFI_MM_SAVE_STATE_REGISTER_MM0 = 264,
>+ EFI_MM_SAVE_STATE_REGISTER_MM1 = 265,
>+ EFI_MM_SAVE_STATE_REGISTER_MM2 = 266,
>+ EFI_MM_SAVE_STATE_REGISTER_MM3 = 267,
>+ EFI_MM_SAVE_STATE_REGISTER_MM4 = 268,
>+ EFI_MM_SAVE_STATE_REGISTER_MM5 = 269,
>+ EFI_MM_SAVE_STATE_REGISTER_MM6 = 270,
>+ EFI_MM_SAVE_STATE_REGISTER_MM7 = 271,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM0 = 272,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM1 = 273,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM2 = 274,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM3 = 275,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM4 = 276,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM5 = 277,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM6 = 278,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM7 = 279,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM8 = 280,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM9 = 281,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM10 = 282,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM11 = 283,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM12 = 284,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM13 = 285,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM14 = 286,
>+ EFI_MM_SAVE_STATE_REGISTER_XMM15 = 287,
>+ ///
>+ /// Pseudo-Registers
>+ ///
>+ EFI_MM_SAVE_STATE_REGISTER_IO = 512,
>+ EFI_MM_SAVE_STATE_REGISTER_LMA = 513,
>+ EFI_MM_SAVE_STATE_REGISTER_PROCESSOR_ID = 514
>+} EFI_MM_SAVE_STATE_REGISTER;
>+
>+///
>+/// The EFI_MM_SAVE_STATE_REGISTER_LMA pseudo-register values
>+/// If the processor acts in 32-bit mode at the time the MMI occurred, the
>pseudo register value
>+/// EFI_MM_SAVE_STATE_REGISTER_LMA_32BIT is returned in Buffer.
>Otherwise,
>+/// EFI_MM_SAVE_STATE_REGISTER_LMA_64BIT is returned in Buffer.
>+///
>+#define EFI_MM_SAVE_STATE_REGISTER_LMA_32BIT 32
>+#define EFI_MM_SAVE_STATE_REGISTER_LMA_64BIT 64
>+
>+///
>+/// Size width of I/O instruction
>+///
>+typedef enum {
>+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT8 = 0,
>+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT16 = 1,
>+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT32 = 2,
>+ EFI_MM_SAVE_STATE_IO_WIDTH_UINT64 = 3
>+} EFI_MM_SAVE_STATE_IO_WIDTH;
>+
>+///
>+/// Types of I/O instruction
>+///
>+typedef enum {
>+ EFI_MM_SAVE_STATE_IO_TYPE_INPUT = 1,
>+ EFI_MM_SAVE_STATE_IO_TYPE_OUTPUT = 2,
>+ EFI_MM_SAVE_STATE_IO_TYPE_STRING = 4,
>+ EFI_MM_SAVE_STATE_IO_TYPE_REP_PREFIX = 8
>+} EFI_MM_SAVE_STATE_IO_TYPE;
>+
>+///
>+/// Structure of the data which is returned when ReadSaveState() is called
>with
>+/// EFI_MM_SAVE_STATE_REGISTER_IO. If there was no I/O then
>ReadSaveState() will
>+/// return EFI_NOT_FOUND.
>+///
>+/// This structure describes the I/O operation which was in process when the
>MMI was generated.
>+///
>+typedef struct _EFI_MM_SAVE_STATE_IO_INFO {
>+ ///
>+ /// For input instruction (IN, INS), this is data read before the MMI occurred.
>For output
>+ /// instructions (OUT, OUTS) this is data that was written before the MMI
>occurred. The
>+ /// width of the data is specified by IoWidth.
>+ ///
>+ UINT64 IoData;
>+ ///
>+ /// The I/O port that was being accessed when the MMI was triggered.
>+ ///
>+ UINT16 IoPort;
>+ ///
>+ /// Defines the size width (UINT8, UINT16, UINT32, UINT64) for IoData.
>+ ///
>+ EFI_MM_SAVE_STATE_IO_WIDTH IoWidth;
>+ ///
>+ /// Defines type of I/O instruction.
>+ ///
>+ EFI_MM_SAVE_STATE_IO_TYPE IoType;
>+} EFI_MM_SAVE_STATE_IO_INFO;
>+
>+typedef struct _EFI_MM_CPU_PROTOCOL EFI_MM_CPU_PROTOCOL;
>+
>+/**
>+ Read data from the CPU save state.
>+
>+ This function is used to read the specified number of bytes of the specified
>register from the CPU
>+ save state of the specified CPU and place the value into the buffer. If the
>CPU does not support the
>+ specified register Register, then EFI_NOT_FOUND should be returned. If
>the CPU does not
>+ support the specified register width Width, then EFI_INVALID_PARAMETER
>is returned.
>+
>+ @param[in] This The EFI_MM_CPU_PROTOCOL instance.
>+ @param[in] Width The number of bytes to read from the CPU save
>state.
>+ @param[in] Register Specifies the CPU register to read form the save
>state.
>+ @param[in] CpuIndex Specifies the zero-based index of the CPU save
>state.
>+ @param[out] Buffer Upon return, this holds the CPU register value
>read from the save state.
>+
>+ @retval EFI_SUCCESS The register was read from Save State.
>+ @retval EFI_NOT_FOUND The register is not defined for the Save State
>of Processor.
>+ @retval EFI_INVALID_PARAMETER Input parameters are not valid, for
>example, Processor No or register width
>+ is not correct.This or Buffer is NULL.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_READ_SAVE_STATE)(
>+ IN CONST EFI_MM_CPU_PROTOCOL *This,
>+ IN UINTN Width,
>+ IN EFI_MM_SAVE_STATE_REGISTER Register,
>+ IN UINTN CpuIndex,
>+ OUT VOID *Buffer
>+ );
>+
>+
>+/**
>+ Write data to the CPU save state.
>+
>+ This function is used to write the specified number of bytes of the specified
>register to the CPU save
>+ state of the specified CPU and place the value into the buffer. If the CPU
>does not support the
>+ specified register Register, then EFI_UNSUPPORTED should be returned. If
>the CPU does not
>+ support the specified register width Width, then EFI_INVALID_PARAMETER
>is returned.
>+
>+ @param[in] This The EFI_MM_CPU_PROTOCOL instance.
>+ @param[in] Width The number of bytes to write to the CPU save
>state.
>+ @param[in] Register Specifies the CPU register to write to the save
>state.
>+ @param[in] CpuIndex Specifies the zero-based index of the CPU save
>state.
>+ @param[in] Buffer Upon entry, this holds the new CPU register value.
>+
>+ @retval EFI_SUCCESS The register was written to Save State.
>+ @retval EFI_NOT_FOUND The register is not defined for the Save State
>of Processor.
>+ @retval EFI_INVALID_PARAMETER Input parameters are not valid. For
>example:
>+ ProcessorIndex or Width is not correct.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_WRITE_SAVE_STATE)(
>+ IN CONST EFI_MM_CPU_PROTOCOL *This,
>+ IN UINTN Width,
>+ IN EFI_MM_SAVE_STATE_REGISTER Register,
>+ IN UINTN CpuIndex,
>+ IN CONST VOID *Buffer
>+ );
>+
>+///
>+/// EFI MM CPU Protocol provides access to CPU-related information while in
>MM.
>+///
>+/// This protocol allows MM drivers to access architecture-standard registers
>from any of the CPU
>+/// save state areas. In some cases, difference processors provide the same
>information in the save state,
>+/// but not in the same format. These so-called pseudo-registers provide this
>information in a standard
>+/// format.
>+///
>+struct _EFI_MM_CPU_PROTOCOL {
>+ EFI_MM_READ_SAVE_STATE ReadSaveState;
>+ EFI_MM_WRITE_SAVE_STATE WriteSaveState;
>+};
>+
>+extern EFI_GUID gEfiMmCpuProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmCpuIo.h
>b/MdePkg/Include/Protocol/MmCpuIo.h
>new file mode 100644
>index 0000000..9fda26c
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmCpuIo.h
>@@ -0,0 +1,96 @@
>+/** @file
>+ MM CPU I/O 2 protocol as defined in the PI 1.2 specification.
>+
>+ This protocol provides CPU I/O and memory access within MM.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_CPU_IO_H_
>+#define _MM_CPU_IO_H_
>+
>+#define EFI_MM_CPU_IO_PROTOCOL_GUID \
>+ { \
>+ 0x3242A9D8, 0xCE70, 0x4AA0, { 0x95, 0x5D, 0x5E, 0x7B, 0x14, 0x0D, 0xE4,
>0xD2 } \
>+ }
>+
>+typedef struct _EFI_MM_CPU_IO_PROTOCOL
>EFI_MM_CPU_IO_PROTOCOL;
>+
>+///
>+/// Width of the MM CPU I/O operations
>+///
>+typedef enum {
>+ MM_IO_UINT8 = 0,
>+ MM_IO_UINT16 = 1,
>+ MM_IO_UINT32 = 2,
>+ MM_IO_UINT64 = 3
>+} EFI_MM_IO_WIDTH;
>+
>+/**
>+ Provides the basic memory and I/O interfaces used toabstract accesses to
>devices.
>+
>+ The I/O operations are carried out exactly as requested. The caller is
>+ responsible for any alignment and I/O width issues that the bus, device,
>+ platform, or type of I/O might require.
>+
>+ @param[in] This The EFI_MM_CPU_IO_PROTOCOL instance.
>+ @param[in] Width Signifies the width of the I/O operations.
>+ @param[in] Address The base address of the I/O operations. The caller
>is
>+ responsible for aligning the Address if required.
>+ @param[in] Count The number of I/O operations to perform.
>+ @param[in,out] Buffer For read operations, the destination buffer to
>store
>+ the results. For write operations, the source buffer
>+ from which to write data.
>+
>+ @retval EFI_SUCCESS The data was read from or written to the device.
>+ @retval EFI_UNSUPPORTED The Address is not valid for this system.
>+ @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid.
>+ @retval EFI_OUT_OF_RESOURCES The request could not be completed
>due to a lack
>+ of resources.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_CPU_IO)(
>+ IN CONST EFI_MM_CPU_IO_PROTOCOL *This,
>+ IN EFI_MM_IO_WIDTH Width,
>+ IN UINT64 Address,
>+ IN UINTN Count,
>+ IN OUT VOID *Buffer
>+ );
>+
>+typedef struct {
>+ ///
>+ /// This service provides the various modalities of memory and I/O read.
>+ ///
>+ EFI_MM_CPU_IO Read;
>+ ///
>+ /// This service provides the various modalities of memory and I/O write.
>+ ///
>+ EFI_MM_CPU_IO Write;
>+} EFI_MM_IO_ACCESS;
>+
>+///
>+/// MM CPU I/O Protocol provides CPU I/O and memory access within MM.
>+///
>+struct _EFI_MM_CPU_IO_PROTOCOL {
>+ ///
>+ /// Allows reads and writes to memory-mapped I/O space.
>+ ///
>+ EFI_MM_IO_ACCESS Mem;
>+ ///
>+ /// Allows reads and writes to I/O space.
>+ ///
>+ EFI_MM_IO_ACCESS Io;
>+};
>+
>+extern EFI_GUID gEfiMmCpuIoProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmEndOfDxe.h
>b/MdePkg/Include/Protocol/MmEndOfDxe.h
>new file mode 100644
>index 0000000..6c3f17a
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmEndOfDxe.h
>@@ -0,0 +1,33 @@
>+/** @file
>+ MM End Of Dxe protocol introduced in the PI 1.2.1 specification.
>+
>+ According to PI 1.4a specification, this protocol indicates end of the
>+ execution phase when all of the components are under the authority of
>+ the platform manufacturer.
>+ This protocol is a mandatory protocol published by MM Foundation code.
>+ This protocol is an MM counterpart of the End of DXE Event.
>+ This protocol prorogates End of DXE notification into MM environment.
>+ This protocol is installed prior to installation of the MM Ready to Lock
>Protocol.
>+
>+ Copyright (c) 2012 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_END_OF_DXE_H_
>+#define _MM_END_OF_DXE_H_
>+
>+#define EFI_MM_END_OF_DXE_PROTOCOL_GUID \
>+ { \
>+ 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }
>\
>+ }
>+
>+extern EFI_GUID gEfiMmEndOfDxeProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmGpiDispatch.h
>b/MdePkg/Include/Protocol/MmGpiDispatch.h
>new file mode 100644
>index 0000000..5682e75
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmGpiDispatch.h
>@@ -0,0 +1,125 @@
>+/** @file
>+ MM General Purpose Input (GPI) Dispatch Protocol as defined in PI 1.1
>Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ This protocol provides the parent dispatch service for the General Purpose
>Input
>+ (GPI) MMI source generator.
>+
>+ The EFI_MM_GPI_DISPATCH_PROTOCOL provides the ability to install child
>handlers for the
>+ given event types. Several inputs can be enabled. This purpose of this
>interface is to generate an
>+ MMI in response to any of these inputs having a true value provided.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+ @par Revision Reference:
>+ This protocol is from PI Version 1.1.
>+
>+**/
>+
>+#ifndef _MM_GPI_DISPATCH_H_
>+#define _MM_GPI_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_GPI_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43,
>0x80 } \
>+ }
>+
>+///
>+/// The dispatch function's context.
>+///
>+typedef struct {
>+ ///
>+ /// A number from one of 2^64 possible GPIs that can generate an MMI. A
>+ /// 0 corresponds to logical GPI[0]; 1 corresponds to logical GPI[1]; and
>+ /// GpiNum of N corresponds to GPI[N], where N can span from 0 to 2^64-1.
>+ ///
>+ UINT64 GpiNum;
>+} EFI_MM_GPI_REGISTER_CONTEXT;
>+
>+typedef struct _EFI_MM_GPI_DISPATCH_PROTOCOL
>EFI_MM_GPI_DISPATCH_PROTOCOL;
>+
>+/**
>+ Registers a child MMI source dispatch function with a parent MM driver.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when an MMI is
>+ generated because of one or more of the GPIs specified by RegisterContext.
>On return,
>+ DispatchHandle contains a unique handle which may be used later to
>unregister the function
>+ using UnRegister().
>+ The DispatchFunction will be called with Context set to the same value as
>was passed into
>+ this function in RegisterContext and with CommBuffer pointing to another
>instance of
>+ EFI_MM_GPI_REGISTER_CONTEXT describing the GPIs which actually
>caused the MMI and
>+ CommBufferSize pointing to the size of the structure.
>+
>+ @param[in] This Pointer to the EFI_MM_GPI_DISPATCH_PROTOCOL
>instance.
>+ @param[in] DispatchFunction Function to register for handler when the
>specified GPI causes an MMI.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>+ The caller fills this context in before calling
>+ the register function to indicate to the register
>+ function the GPI(s) for which the dispatch function
>+ should be invoked.
>+ @param[out] DispatchHandle Handle generated by the dispatcher to
>track the
>+ function instance.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI
>source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The GPI input
>value
>+ is not within valid range.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this child.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_GPI_REGISTER)(
>+ IN CONST EFI_MM_GPI_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN CONST EFI_MM_GPI_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregisters a General Purpose Input (GPI) service.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called when the GPI triggers an MMI.
>+
>+ @param[in] This Pointer to the EFI_MM_GPI_DISPATCH_PROTOCOL
>instance.
>+ @param[in] DispatchHandle Handle of the service to remove.
>+
>+ @retval EFI_SUCCESS Handle of the service to remove.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_GPI_UNREGISTER)(
>+ IN CONST EFI_MM_GPI_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Interface structure for the MM GPI MMI Dispatch Protocol
>+///
>+/// The MM GPI MMI Dispatch Protocol provides the parent dispatch service
>+/// for the General Purpose Input (GPI) MMI source generator.
>+///
>+struct _EFI_MM_GPI_DISPATCH_PROTOCOL {
>+ EFI_MM_GPI_REGISTER Register;
>+ EFI_MM_GPI_UNREGISTER UnRegister;
>+ ///
>+ /// Denotes the maximum value of inputs that can have handlers attached.
>+ ///
>+ UINTN NumSupportedGpis;
>+};
>+
>+extern EFI_GUID gEfiMmGpiDispatchProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmIoTrapDispatch.h
>b/MdePkg/Include/Protocol/MmIoTrapDispatch.h
>new file mode 100644
>index 0000000..ae116a0
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmIoTrapDispatch.h
>@@ -0,0 +1,136 @@
>+/** @file
>+ MM IO Trap Dispatch Protocol as defined in PI 1.1 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ This protocol provides a parent dispatch service for IO trap MMI sources.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+ @par Revision Reference:
>+ This protocol is from PI Version 1.1.
>+
>+**/
>+
>+#ifndef _MM_IO_TRAP_DISPATCH_H_
>+#define _MM_IO_TRAP_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_IO_TRAP_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }
>\
>+ }
>+
>+///
>+/// IO Trap valid types
>+///
>+typedef enum {
>+ WriteTrap,
>+ ReadTrap,
>+ ReadWriteTrap,
>+ IoTrapTypeMaximum
>+} EFI_MM_IO_TRAP_DISPATCH_TYPE;
>+
>+///
>+/// IO Trap context structure containing information about the
>+/// IO trap event that should invoke the handler
>+///
>+typedef struct {
>+ UINT16 Address;
>+ UINT16 Length;
>+ EFI_MM_IO_TRAP_DISPATCH_TYPE Type;
>+} EFI_MM_IO_TRAP_REGISTER_CONTEXT;
>+
>+///
>+/// IO Trap context structure containing information about the IO trap that
>occurred
>+///
>+typedef struct {
>+ UINT32 WriteData;
>+} EFI_MM_IO_TRAP_CONTEXT;
>+
>+typedef struct _EFI_MM_IO_TRAP_DISPATCH_PROTOCOL
>EFI_MM_IO_TRAP_DISPATCH_PROTOCOL;
>+
>+/**
>+ Register an IO trap MMI child handler for a specified MMI.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when an MMI is
>+ generated because of an access to an I/O port specified by RegisterContext.
>On return,
>+ DispatchHandle contains a unique handle which may be used later to
>unregister the function
>+ using UnRegister(). If the base of the I/O range specified is zero, then an
>I/O range with the
>+ specified length and characteristics will be allocated and the Address field in
>RegisterContext
>+ updated. If no range could be allocated, then EFI_OUT_OF_RESOURCES will
>be returned.
>+
>+ The service will not perform GCD allocation if the base address is non-zero
>or
>+ EFI_MM_READY_TO_LOCK has been installed. In this case, the caller is
>responsible for the
>+ existence and allocation of the specific IO range.
>+ An error may be returned if some or all of the requested resources conflict
>with an existing IO trap
>+ child handler.
>+
>+ It is not required that implementations will allow multiple children for a
>single IO trap MMI source.
>+ Some implementations may support multiple children.
>+ The DispatchFunction will be called with Context updated to contain
>information
>+ concerning the I/O action that actually happened and is passed in
>RegisterContext, with
>+ CommBuffer pointing to the data actually written and CommBufferSize
>pointing to the size of
>+ the data in CommBuffer.
>+
>+ @param[in] This Pointer to the
>EFI_MM_IO_TRAP_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchFunction Function to register for handler when I/O
>trap location is accessed.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>The caller fills this
>+ context in before calling the register function to indicate to
>the register
>+ function the IO trap MMI source for which the dispatch
>function should be invoked.
>+ @param[out] DispatchHandle Handle of the dispatch function, for when
>interfacing with the parent MM driver.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>registered.
>+ @retval EFI_DEVICE_ERROR The driver was unable to complete due to
>hardware error.
>+ @retval EFI_OUT_OF_RESOURCES Insufficient resources are available to
>fulfill the IO trap range request.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The input
>value is not within a valid range.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_IO_TRAP_DISPATCH_REGISTER)(
>+ IN CONST EFI_MM_IO_TRAP_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN OUT EFI_MM_IO_TRAP_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregister a child MMI source dispatch function with a parent MM driver.
>+
>+ This service removes a previously installed child dispatch handler. This does
>not guarantee that the
>+ system resources will be freed from the GCD.
>+
>+ @param[in] This Pointer to the
>EFI_MM_IO_TRAP_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchHandle Handle of the child service to remove.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>unregistered.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_IO_TRAP_DISPATCH_UNREGISTER)(
>+ IN CONST EFI_MM_IO_TRAP_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Interface structure for the MM IO Trap Dispatch Protocol.
>+///
>+/// This protocol provides a parent dispatch service for IO trap MMI sources.
>+///
>+struct _EFI_MM_IO_TRAP_DISPATCH_PROTOCOL {
>+ EFI_MM_IO_TRAP_DISPATCH_REGISTER Register;
>+ EFI_MM_IO_TRAP_DISPATCH_UNREGISTER UnRegister;
>+};
>+
>+extern EFI_GUID gEfiMmIoTrapDispatchProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmPciRootBridgeIo.h
>b/MdePkg/Include/Protocol/MmPciRootBridgeIo.h
>new file mode 100644
>index 0000000..a3f3946
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmPciRootBridgeIo.h
>@@ -0,0 +1,37 @@
>+/** @file
>+ MM PCI Root Bridge IO protocol as defined in the PI 1.2 specification.
>+
>+ This protocol provides PCI I/O and memory access within MM.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_PCI_ROOT_BRIDGE_IO_H_
>+#define _MM_PCI_ROOT_BRIDGE_IO_H_
>+
>+#include <Protocol/PciRootBridgeIo.h>
>+
>+#define EFI_MM_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
>+ { \
>+ 0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98,
>0xea } \
>+ }
>+
>+///
>+/// This protocol provides the same functionality as the PCI Root Bridge I/O
>Protocol defined in the
>+/// UEFI 2.1 Specifcation, section 13.2, except that the functions for Map()
>and Unmap() may return
>+/// EFI_UNSUPPORTED.
>+///
>+typedef EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
>EFI_MM_PCI_ROOT_BRIDGE_IO_PROTOCOL;
>+
>+extern EFI_GUID gEfiMmPciRootBridgeIoProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
>b/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
>new file mode 100644
>index 0000000..4f88dc8
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h
>@@ -0,0 +1,170 @@
>+/** @file
>+ MM Periodic Timer Dispatch Protocol as defined in PI 1.1 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ This protocol provides the parent dispatch service for the periodical timer
>MMI source generator.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+ @par Revision Reference:
>+ This protocol is from PI Version 1.1.
>+
>+**/
>+
>+#ifndef _MM_PERIODIC_TIMER_DISPATCH_H_
>+#define _MM_PERIODIC_TIMER_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a,
>0x53 } \
>+ }
>+
>+///
>+/// Example: A chipset supports periodic MMIs on every 64ms or 2 seconds.
>+/// A child wishes schedule a period MMI to fire on a period of 3 seconds,
>there
>+/// are several ways to approach the problem:
>+/// 1. The child may accept a 4 second periodic rate, in which case it registers
>with
>+/// Period = 40000
>+/// MmiTickInterval = 20000
>+/// The resulting MMI will occur every 2 seconds with the child called back
>on
>+/// every 2nd MMI.
>+/// NOTE: the same result would occur if the child set MmiTickInterval = 0.
>+/// 2. The child may choose the finer granularity MMI (64ms):
>+/// Period = 30000
>+/// MmiTickInterval = 640
>+/// The resulting MMI will occur every 64ms with the child called back on
>+/// every 47th MMI.
>+/// NOTE: the child driver should be aware that this will result in more
>+/// MMIs occuring during system runtime which can negatively impact
>system
>+/// performance.
>+///
>+typedef struct {
>+ ///
>+ /// The minimum period of time in 100 nanosecond units that the child gets
>called. The
>+ /// child will be called back after a time greater than the time Period.
>+ ///
>+ UINT64 Period;
>+ ///
>+ /// The period of time interval between MMIs. Children of this interface
>should use this
>+ /// field when registering for periodic timer intervals when a finer
>granularity periodic
>+ /// MMI is desired.
>+ ///
>+ UINT64 MmiTickInterval;
>+} EFI_MM_PERIODIC_TIMER_REGISTER_CONTEXT;
>+
>+///
>+/// The DispatchFunction will be called with Context set to the same value as
>was passed into
>+/// Register() in RegisterContext and with CommBuffer pointing to an
>instance of
>+/// EFI_MM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to
>its size.
>+///
>+typedef struct {
>+ ///
>+ /// ElapsedTime is the actual time in 100 nanosecond units elapsed since last
>called, a
>+ /// value of 0 indicates an unknown amount of time.
>+ ///
>+ UINT64 ElapsedTime;
>+} EFI_MM_PERIODIC_TIMER_CONTEXT;
>+
>+typedef struct _EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL
>EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL;
>+
>+/**
>+ Register a child MMI source dispatch function for MM periodic timer.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when at least the
>+ amount of time specified by RegisterContext has elapsed. On return,
>DispatchHandle
>+ contains a unique handle which may be used later to unregister the
>function using UnRegister().
>+ The DispatchFunction will be called with Context set to the same value as
>was passed into
>+ this function in RegisterContext and with CommBuffer pointing to an
>instance of
>+ EFI_MM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its
>size.
>+
>+ @param[in] This Pointer to the
>EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchFunction Function to register for handler when at
>least the specified amount
>+ of time has elapsed.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>+ The caller fills this context in before calling
>+ the register function to indicate to the register
>+ function the period at which the dispatch function
>+ should be invoked.
>+ @param[out] DispatchHandle Handle generated by the dispatcher to
>track the function instance.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI
>source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The period
>input value
>+ is not within valid range.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this child.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_PERIODIC_TIMER_REGISTER)(
>+ IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN CONST EFI_MM_PERIODIC_TIMER_REGISTER_CONTEXT
>*RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregisters a periodic timer service.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called when the time has elapsed.
>+
>+ @param[in] This Pointer to the
>EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchHandle Handle of the service to remove.
>+
>+ @retval EFI_SUCCESS The service has been successfully removed.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_PERIODIC_TIMER_UNREGISTER)(
>+ IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+/**
>+ Returns the next MMI tick period supported by the chipset.
>+
>+ The order returned is from longest to shortest interval period.
>+
>+ @param[in] This Pointer to the
>EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
>+ @param[in,out] MmiTickInterval Pointer to pointer of next shorter MMI
>interval
>+ period supported by the child. This parameter works as a
>get-first,
>+ get-next field.The first time this function is called,
>*MmiTickInterval
>+ should be set to NULL to get the longest MMI interval.The
>returned
>+ *MmiTickInterval should be passed in on subsequent calls
>to get the
>+ next shorter interval period until *MmiTickInterval = NULL.
>+
>+ @retval EFI_SUCCESS The service returned successfully.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_PERIODIC_TIMER_INTERVAL)(
>+ IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
>+ IN OUT UINT64 **MmiTickInterval
>+ );
>+
>+///
>+/// Interface structure for the MM Periodic Timer Dispatch Protocol
>+///
>+/// This protocol provides the parent dispatch service for the periodical timer
>MMI source generator.
>+///
>+struct _EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL {
>+ EFI_MM_PERIODIC_TIMER_REGISTER Register;
>+ EFI_MM_PERIODIC_TIMER_UNREGISTER UnRegister;
>+ EFI_MM_PERIODIC_TIMER_INTERVAL GetNextShorterInterval;
>+};
>+
>+extern EFI_GUID gEfiMmPeriodicTimerDispatchProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmPowerButtonDispatch.h
>b/MdePkg/Include/Protocol/MmPowerButtonDispatch.h
>new file mode 100644
>index 0000000..7f1a4e2
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmPowerButtonDispatch.h
>@@ -0,0 +1,117 @@
>+/** @file
>+ MM Power Button Dispatch Protocol as defined in PI 1.1 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ This protocol provides the parent dispatch service for the power button
>MMI source generator.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+ @par Revision Reference:
>+ This protocol is from PI Version 1.1.
>+
>+**/
>+
>+#ifndef _MM_POWER_BUTTON_DISPATCH_H_
>+#define _MM_POWER_BUTTON_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }
>\
>+ }
>+
>+///
>+/// Power Button phases.
>+///
>+typedef enum {
>+ EfiPowerButtonEntry,
>+ EfiPowerButtonExit,
>+ EfiPowerButtonMax
>+} EFI_POWER_BUTTON_PHASE;
>+
>+///
>+/// The dispatch function's context.
>+///
>+typedef struct {
>+ ///
>+ /// Designates whether this handler should be invoked upon entry or exit.
>+ ///
>+ EFI_POWER_BUTTON_PHASE Phase;
>+} EFI_MM_POWER_BUTTON_REGISTER_CONTEXT;
>+
>+typedef struct _EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL
>EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL;
>+
>+/**
>+ Provides the parent dispatch service for a power button event.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when an MMI is
>+ generated because the power button was pressed or released, as specified
>by RegisterContext.
>+ On return, DispatchHandle contains a unique handle which may be used
>later to unregister the
>+ function using UnRegister().
>+ The DispatchFunction will be called with Context set to the same value as
>was passed into
>+ this function in RegisterContext and with CommBuffer and CommBufferSize
>set to NULL.
>+
>+ @param[in] This Pointer to the
>EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchFunction Function to register for handler when
>power button is pressed or released.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>The caller fills in this context
>+ before calling the Register() function to indicate to the
>Register() function
>+ the power button MMI phase for which the dispatch
>function should be invoked.
>+ @param[out] DispatchHandle Handle generated by the dispatcher to
>track the function instance.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI
>source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The power
>button input value
>+ is not within valid range.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this child.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_POWER_BUTTON_REGISTER)(
>+ IN CONST EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN EFI_MM_POWER_BUTTON_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregisters a power-button service.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called when the standby button is pressed or released.
>+
>+ @param[in] This Pointer to the
>EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchHandle Handle of the service to remove.
>+
>+ @retval EFI_SUCCESS The service has been successfully removed.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_POWER_BUTTON_UNREGISTER)(
>+ IN CONST EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Interface structure for the MM Power Button Dispatch Protocol.
>+///
>+/// This protocol provides the parent dispatch service for the power button
>MMI source generator.
>+///
>+struct _EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL {
>+ EFI_MM_POWER_BUTTON_REGISTER Register;
>+ EFI_MM_POWER_BUTTON_UNREGISTER UnRegister;
>+};
>+
>+extern EFI_GUID gEfiMmPowerButtonDispatchProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmReadyToLock.h
>b/MdePkg/Include/Protocol/MmReadyToLock.h
>new file mode 100644
>index 0000000..7752c71
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmReadyToLock.h
>@@ -0,0 +1,35 @@
>+/** @file
>+ MM Ready To Lock protocol introduced in the PI 1.2 specification.
>+
>+ According to PI 1.4a specification, this MM protocol indicates that
>+ MM resources and services that should not be used by the third party
>+ code are about to be locked.
>+ This protocol is a mandatory protocol published by the MM Foundation
>+ code when the system is preparing to lock certain resources and interfaces
>+ in anticipation of the invocation of 3rd party extensible modules.
>+ This protocol is an MM counterpart of the DXE MM Ready to Lock Protocol.
>+ This protocol prorogates resource locking notification into MM environment.
>+ This protocol is installed after installation of the MM End of DXE Protocol.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_READY_TO_LOCK_H_
>+#define _MM_READY_TO_LOCK_H_
>+
>+#define EFI_MM_READY_TO_LOCK_PROTOCOL_GUID \
>+ { \
>+ 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }
>\
>+ }
>+
>+extern EFI_GUID gEfiMmReadyToLockProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
>b/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
>new file mode 100644
>index 0000000..9f967b3
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h
>@@ -0,0 +1,81 @@
>+/** @file
>+ This protocol provides registering and unregistering services to status code
>consumers while in DXE MM.
>+
>+ Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef __MM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
>+#define __MM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
>+
>+#define EFI_MM_RSC_HANDLER_PROTOCOL_GUID \
>+ { \
>+ 0x2ff29fa7, 0x5e80, 0x4ed9, {0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4} \
>+ }
>+
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_RSC_HANDLER_CALLBACK)(
>+ IN EFI_STATUS_CODE_TYPE CodeType,
>+ IN EFI_STATUS_CODE_VALUE Value,
>+ IN UINT32 Instance,
>+ IN EFI_GUID *CallerId,
>+ IN EFI_STATUS_CODE_DATA *Data
>+);
>+
>+/**
>+ Register the callback function for ReportStatusCode() notification.
>+
>+ When this function is called the function pointer is added to an internal list
>and any future calls to
>+ ReportStatusCode() will be forwarded to the Callback function.
>+
>+ @param[in] Callback A pointer to a function of type
>EFI_MM_RSC_HANDLER_CALLBACK that is
>+ called when a call to ReportStatusCode() occurs.
>+
>+ @retval EFI_SUCCESS Function was successfully registered.
>+ @retval EFI_INVALID_PARAMETER The callback function was NULL.
>+ @retval EFI_OUT_OF_RESOURCES The internal buffer ran out of space.
>No more functions can be
>+ registered.
>+ @retval EFI_ALREADY_STARTED The function was already registered. It
>can't be registered again.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_RSC_HANDLER_REGISTER)(
>+ IN EFI_MM_RSC_HANDLER_CALLBACK Callback
>+);
>+
>+/**
>+ Remove a previously registered callback function from the notification list.
>+
>+ A callback function must be unregistered before it is deallocated. It is
>important that any registered
>+ callbacks that are not runtime complaint be unregistered when
>ExitBootServices() is called.
>+
>+ @param[in] Callback A pointer to a function of type
>EFI_MM_RSC_HANDLER_CALLBACK that is to be
>+ unregistered.
>+
>+ @retval EFI_SUCCESS The function was successfully unregistered.
>+ @retval EFI_INVALID_PARAMETER The callback function was NULL.
>+ @retval EFI_NOT_FOUND The callback function was not found to be
>unregistered.
>+
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_RSC_HANDLER_UNREGISTER)(
>+ IN EFI_MM_RSC_HANDLER_CALLBACK Callback
>+);
>+
>+typedef struct _EFI_MM_RSC_HANDLER_PROTOCOL {
>+ EFI_MM_RSC_HANDLER_REGISTER Register;
>+ EFI_MM_RSC_HANDLER_UNREGISTER Unregister;
>+} EFI_MM_RSC_HANDLER_PROTOCOL;
>+
>+extern EFI_GUID gEfiMmRscHandlerProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
>b/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
>new file mode 100644
>index 0000000..7dcb49c
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h
>@@ -0,0 +1,119 @@
>+/** @file
>+ MM Standby Button Dispatch Protocol as defined in PI 1.1 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ This protocol provides the parent dispatch service for the standby button
>MMI source generator.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+ @par Revision Reference:
>+ This protocol is from PI Version 1.1.
>+
>+**/
>+
>+#ifndef _MM_STANDBY_BUTTON_DISPATCH_H_
>+#define _MM_STANDBY_BUTTON_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }
>\
>+ }
>+
>+///
>+/// Standby Button phases
>+///
>+typedef enum {
>+ EfiStandbyButtonEntry,
>+ EfiStandbyButtonExit,
>+ EfiStandbyButtonMax
>+} EFI_STANDBY_BUTTON_PHASE;
>+
>+///
>+/// The dispatch function's context.
>+///
>+typedef struct {
>+ ///
>+ /// Describes whether the child handler should be invoked upon the entry
>to the button
>+ /// activation or upon exit.
>+ ///
>+ EFI_STANDBY_BUTTON_PHASE Phase;
>+} EFI_MM_STANDBY_BUTTON_REGISTER_CONTEXT;
>+
>+typedef struct _EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL
>EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL;
>+
>+/**
>+ Provides the parent dispatch service for a standby button event.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when an MMI is
>+ generated because the standby button was pressed or released, as
>specified by
>+ RegisterContext. On return, DispatchHandle contains a unique handle which
>may be used
>+ later to unregister the function using UnRegister().
>+ The DispatchFunction will be called with Context set to the same value as
>was passed into
>+ this function in RegisterContext and with CommBuffer and CommBufferSize
>set to NULL.
>+
>+ @param[in] This Pointer to the
>EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchFunction Function to register for handler when the
>standby button is pressed or released.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>The caller fills in this context
>+ before calling the register function to indicate to the register
>function the
>+ standby button MMI source for which the dispatch function
>should be invoked.
>+ @param[out] DispatchHandle Handle generated by the dispatcher to
>track the function instance.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI
>source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The standby
>button input value
>+ is not within valid range.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this child.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_STANDBY_BUTTON_REGISTER)(
>+ IN CONST EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN EFI_MM_STANDBY_BUTTON_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregisters a child MMI source dispatch function with a parent MM driver.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called when the standby button is pressed or released.
>+
>+ @param[in] This Pointer to the
>EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchHandle Handle of the service to remove.
>+
>+ @retval EFI_SUCCESS The service has been successfully removed.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_STANDBY_BUTTON_UNREGISTER)(
>+ IN CONST EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Interface structure for the MM Standby Button Dispatch Protocol.
>+///
>+/// This protocol provides the parent dispatch service for the standby
>+/// button MMI source generator.
>+///
>+struct _EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL {
>+ EFI_MM_STANDBY_BUTTON_REGISTER Register;
>+ EFI_MM_STANDBY_BUTTON_UNREGISTER UnRegister;
>+};
>+
>+extern EFI_GUID gEfiMmStandbyButtonDispatchProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmStatusCode.h
>b/MdePkg/Include/Protocol/MmStatusCode.h
>new file mode 100644
>index 0000000..d0bfbac
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmStatusCode.h
>@@ -0,0 +1,65 @@
>+/** @file
>+ EFI MM Status Code Protocol as defined in the PI 1.2 specification.
>+
>+ This protocol provides the basic status code services while in MM.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_STATUS_CODE_H__
>+#define _MM_STATUS_CODE_H__
>+
>+
>+#define EFI_MM_STATUS_CODE_PROTOCOL_GUID \
>+ { \
>+ 0x6afd2b77, 0x98c1, 0x4acd, {0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}
>\
>+ }
>+
>+typedef struct _EFI_MM_STATUS_CODE_PROTOCOL
>EFI_MM_STATUS_CODE_PROTOCOL;
>+
>+/**
>+ Service to emit the status code in MM.
>+
>+ The EFI_MM_STATUS_CODE_PROTOCOL.ReportStatusCode() function
>enables a driver
>+ to emit a status code while in MM. The reason that there is a separate
>protocol definition from the
>+ DXE variant of this service is that the publisher of this protocol will provide a
>service that is
>+ capability of coexisting with a foreground operational environment, such as
>an operating system
>+ after the termination of boot services.
>+
>+ @param[in] This Points to this instance of the
>EFI_MM_STATUS_CODE_PROTOCOL.
>+ @param[in] CodeType DIndicates the type of status code being
>reported.
>+ @param[in] Value Describes the current status of a hardware or
>software entity.
>+ @param[in] Instance The enumeration of a hardware or software
>entity within the system.
>+ @param[in] CallerId This optional parameter may be used to identify
>the caller.
>+ @param[in] Data This optional parameter may be used to pass
>additional data.
>+
>+ @retval EFI_SUCCESS The function completed successfully.
>+ @retval EFI_INVALID_PARAMETER The function should not be completed
>due to a device error.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_REPORT_STATUS_CODE)(
>+ IN CONST EFI_MM_STATUS_CODE_PROTOCOL *This,
>+ IN EFI_STATUS_CODE_TYPE CodeType,
>+ IN EFI_STATUS_CODE_VALUE Value,
>+ IN UINT32 Instance,
>+ IN CONST EFI_GUID *CallerId,
>+ IN EFI_STATUS_CODE_DATA *Data OPTIONAL
>+ );
>+
>+struct _EFI_MM_STATUS_CODE_PROTOCOL {
>+ EFI_MM_REPORT_STATUS_CODE ReportStatusCode;
>+};
>+
>+extern EFI_GUID gEfiMmStatusCodeProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/Include/Protocol/MmSwDispatch.h
>b/MdePkg/Include/Protocol/MmSwDispatch.h
>new file mode 100644
>index 0000000..004c235
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmSwDispatch.h
>@@ -0,0 +1,136 @@
>+/** @file
>+ MM Software Dispatch Protocol introduced from PI 1.2 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ This protocol provides the parent dispatch service for a given MMI source
>generator.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_SW_DISPATCH2_H_
>+#define _MM_SW_DISPATCH2_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_SW_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }
>\
>+ }
>+
>+///
>+/// A particular chipset may not support all possible software MMI input
>values.
>+/// For example, the ICH supports only values 00h to 0FFh. The parent only
>allows a single
>+/// child registration for each SwMmiInputValue.
>+///
>+typedef struct {
>+ UINTN SwMmiInputValue;
>+} EFI_MM_SW_REGISTER_CONTEXT;
>+
>+///
>+/// The DispatchFunction will be called with Context set to the same value as
>was passed into
>+/// this function in RegisterContext and with CommBuffer (and
>CommBufferSize) pointing
>+/// to an instance of EFI_MM_SW_CONTEXT indicating the index of the CPU
>which generated the
>+/// software MMI.
>+///
>+typedef struct {
>+ ///
>+ /// The 0-based index of the CPU which generated the software MMI.
>+ ///
>+ UINTN SwMmiCpuIndex;
>+ ///
>+ /// This value corresponds directly to the CommandPort parameter used in
>the call to Trigger().
>+ ///
>+ UINT8 CommandPort;
>+ ///
>+ /// This value corresponds directly to the DataPort parameter used in the
>call to Trigger().
>+ ///
>+ UINT8 DataPort;
>+} EFI_MM_SW_CONTEXT;
>+
>+typedef struct _EFI_MM_SW_DISPATCH_PROTOCOL
>EFI_MM_SW_DISPATCH_PROTOCOL;
>+
>+/**
>+ Register a child MMI source dispatch function for the specified software
>MMI.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when the software
>+ MMI source specified by RegisterContext->SwMmiCpuIndex is detected.
>On return,
>+ DispatchHandle contains a unique handle which may be used later to
>unregister the function
>+ using UnRegister().
>+
>+ @param[in] This Pointer to the
>EFI_MM_SW_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchFunction Function to register for handler when the
>specified software
>+ MMI is generated.
>+ @param[in, out] RegisterContext Pointer to the dispatch function's context.
>+ The caller fills this context in before calling
>+ the register function to indicate to the register
>+ function which Software MMI input value the
>+ dispatch function should be invoked for.
>+ @param[out] DispatchHandle Handle generated by the dispatcher to
>track the
>+ function instance.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_DEVICE_ERROR The SW driver was unable to enable the
>MMI source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The SW MMI
>input value
>+ is not within a valid range or is already in use.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this
>+ child.
>+ @retval EFI_OUT_OF_RESOURCES A unique software MMI value could not
>be assigned
>+ for this dispatch.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_SW_REGISTER)(
>+ IN CONST EFI_MM_SW_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN OUT EFI_MM_SW_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregister a child MMI source dispatch function for the specified software
>MMI.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called in response to a software MMI.
>+
>+ @param[in] This Pointer to the EFI_MM_SW_DISPATCH_PROTOCOL
>instance.
>+ @param[in] DispatchHandle Handle of dispatch function to deregister.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>unregistered.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_SW_UNREGISTER)(
>+ IN CONST EFI_MM_SW_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+);
>+
>+///
>+/// Interface structure for the MM Software MMI Dispatch Protocol.
>+///
>+/// The EFI_MM_SW_DISPATCH2_PROTOCOL provides the ability to install
>child handlers for the
>+/// given software. These handlers will respond to software interrupts, and
>the maximum software
>+/// interrupt in the EFI_MM_SW_REGISTER_CONTEXT is denoted by
>MaximumSwiValue.
>+///
>+struct _EFI_MM_SW_DISPATCH_PROTOCOL {
>+ EFI_MM_SW_REGISTER Register;
>+ EFI_MM_SW_UNREGISTER UnRegister;
>+ ///
>+ /// A read-only field that describes the maximum value that can be used in
>the
>+ /// EFI_MM_SW_DISPATCH_PROTOCOL.Register() service.
>+ ///
>+ UINTN MaximumSwiValue;
>+};
>+
>+extern EFI_GUID gEfiMmSwDispatchProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmSxDispatch.h
>b/MdePkg/Include/Protocol/MmSxDispatch.h
>new file mode 100644
>index 0000000..af63389
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmSxDispatch.h
>@@ -0,0 +1,135 @@
>+/** @file
>+ MM Sx Dispatch Protocol as defined in PI 1.2 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ Provides the parent dispatch service for a given Sx-state source generator.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef _MM_SX_DISPATCH_H_
>+#define _MM_SX_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_SX_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99,
>0x7d } \
>+ }
>+
>+///
>+/// Sleep states S0-S5
>+///
>+typedef enum {
>+ SxS0,
>+ SxS1,
>+ SxS2,
>+ SxS3,
>+ SxS4,
>+ SxS5,
>+ EfiMaximumSleepType
>+} EFI_SLEEP_TYPE;
>+
>+///
>+/// Sleep state phase: entry or exit
>+///
>+typedef enum {
>+ SxEntry,
>+ SxExit,
>+ EfiMaximumPhase
>+} EFI_SLEEP_PHASE;
>+
>+///
>+/// The dispatch function's context
>+///
>+typedef struct {
>+ EFI_SLEEP_TYPE Type;
>+ EFI_SLEEP_PHASE Phase;
>+} EFI_MM_SX_REGISTER_CONTEXT;
>+
>+typedef struct _EFI_MM_SX_DISPATCH_PROTOCOL
>EFI_MM_SX_DISPATCH_PROTOCOL;
>+
>+/**
>+ Provides the parent dispatch service for a given Sx source generator.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when the sleep state
>+ event specified by RegisterContext is detected. On return, DispatchHandle
>contains a
>+ unique handle which may be used later to unregister the function using
>UnRegister().
>+ The DispatchFunction will be called with Context set to the same value as
>was passed into
>+ this function in RegisterContext and with CommBuffer and CommBufferSize
>set to
>+ NULL and 0 respectively.
>+
>+ @param[in] This Pointer to the EFI_MM_SX_DISPATCH_PROTOCOL
>instance.
>+ @param[in] DispatchFunction Function to register for handler when the
>specified sleep state event occurs.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>+ The caller fills this context in before calling
>+ the register function to indicate to the register
>+ function which Sx state type and phase the caller
>+ wishes to be called back on. For this intertace,
>+ the Sx driver will call the registered handlers for
>+ all Sx type and phases, so the Sx state handler(s)
>+ must check the Type and Phase field of the Dispatch
>+ context and act accordingly.
>+ @param[out] DispatchHandle Handle of dispatch function, for when
>interfacing
>+ with the parent Sx state MM driver.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_UNSUPPORTED The Sx driver or hardware does not support
>that
>+ Sx Type/Phase.
>+ @retval EFI_DEVICE_ERROR The Sx driver was unable to enable the MMI
>source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. Type & Phase
>are not
>+ within valid range.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this
>+ child.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_SX_REGISTER)(
>+ IN CONST EFI_MM_SX_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN CONST EFI_MM_SX_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregisters an Sx-state service.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called in response to sleep event.
>+
>+ @param[in] This Pointer to the EFI_MM_SX_DISPATCH_PROTOCOL
>instance.
>+ @param[in] DispatchHandle Handle of the service to remove.
>+
>+ @retval EFI_SUCCESS The service has been successfully removed.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_SX_UNREGISTER)(
>+ IN CONST EFI_MM_SX_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Interface structure for the MM Sx Dispatch Protocol
>+///
>+/// The EFI_MM_SX_DISPATCH_PROTOCOL provides the ability to install
>child handlers to
>+/// respond to sleep state related events.
>+///
>+struct _EFI_MM_SX_DISPATCH_PROTOCOL {
>+ EFI_MM_SX_REGISTER Register;
>+ EFI_MM_SX_UNREGISTER UnRegister;
>+};
>+
>+extern EFI_GUID gEfiMmSxDispatchProtocolGuid;
>+
>+#endif
>diff --git a/MdePkg/Include/Protocol/MmUsbDispatch.h
>b/MdePkg/Include/Protocol/MmUsbDispatch.h
>new file mode 100644
>index 0000000..0b4fabe
>--- /dev/null
>+++ b/MdePkg/Include/Protocol/MmUsbDispatch.h
>@@ -0,0 +1,130 @@
>+/** @file
>+ MM USB Dispatch Protocol as defined in PI 1.1 Specification
>+ Volume 4 Management Mode Core Interface.
>+
>+ Provides the parent dispatch service for the USB MMI source generator.
>+
>+ Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+ @par Revision Reference:
>+ This protocol is from PI Version 1.1.
>+
>+**/
>+
>+#ifndef _MM_USB_DISPATCH_H_
>+#define _MM_USB_DISPATCH_H_
>+
>+#include <Pi/PiMmCis.h>
>+
>+#define EFI_MM_USB_DISPATCH_PROTOCOL_GUID \
>+ { \
>+ 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc,
>0xa1 } \
>+ }
>+
>+///
>+/// USB MMI event types
>+///
>+typedef enum {
>+ UsbLegacy,
>+ UsbWake
>+} EFI_USB_MMI_TYPE;
>+
>+///
>+/// The dispatch function's context.
>+///
>+typedef struct {
>+ ///
>+ /// Describes whether this child handler will be invoked in response to a
>USB legacy
>+ /// emulation event, such as port-trap on the PS/2* keyboard control
>registers, or to a
>+ /// USB wake event, such as resumption from a sleep state.
>+ ///
>+ EFI_USB_MMI_TYPE Type;
>+ ///
>+ /// The device path is part of the context structure and describes the
>location of the
>+ /// particular USB host controller in the system for which this register event
>will occur.
>+ /// This location is important because of the possible integration of several
>USB host
>+ /// controllers in a system.
>+ ///
>+ EFI_DEVICE_PATH_PROTOCOL *Device;
>+} EFI_MM_USB_REGISTER_CONTEXT;
>+
>+typedef struct _EFI_MM_USB_DISPATCH_PROTOCOL
>EFI_MM_USB_DISPATCH_PROTOCOL;
>+
>+/**
>+ Provides the parent dispatch service for the USB MMI source generator.
>+
>+ This service registers a function (DispatchFunction) which will be called
>when the USB-
>+ related MMI specified by RegisterContext has occurred. On return,
>DispatchHandle
>+ contains a unique handle which may be used later to unregister the
>function using UnRegister().
>+ The DispatchFunction will be called with Context set to the same value as
>was passed into
>+ this function in RegisterContext and with CommBuffer containing NULL and
>+ CommBufferSize containing zero.
>+
>+ @param[in] This Pointer to the
>EFI_MM_USB_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchFunction Function to register for handler when a
>USB-related MMI occurs.
>+ @param[in] RegisterContext Pointer to the dispatch function's context.
>+ The caller fills this context in before calling
>+ the register function to indicate to the register
>+ function the USB MMI types for which the dispatch
>+ function should be invoked.
>+ @param[out] DispatchHandle Handle generated by the dispatcher to
>track the function instance.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ registered and the MMI source has been enabled.
>+ @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI
>source.
>+ @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The USB MMI
>type
>+ is not within valid range.
>+ @retval EFI_OUT_OF_RESOURCES There is not enough memory (system
>or MM) to manage this child.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_USB_REGISTER)(
>+ IN CONST EFI_MM_USB_DISPATCH_PROTOCOL *This,
>+ IN EFI_MM_HANDLER_ENTRY_POINT DispatchFunction,
>+ IN CONST EFI_MM_USB_REGISTER_CONTEXT *RegisterContext,
>+ OUT EFI_HANDLE *DispatchHandle
>+ );
>+
>+/**
>+ Unregisters a USB service.
>+
>+ This service removes the handler associated with DispatchHandle so that it
>will no longer be
>+ called when the USB event occurs.
>+
>+ @param[in] This Pointer to the
>EFI_MM_USB_DISPATCH_PROTOCOL instance.
>+ @param[in] DispatchHandle Handle of the service to remove.
>+
>+ @retval EFI_SUCCESS The dispatch function has been successfully
>+ unregistered and the MMI source has been disabled
>+ if there are no other registered child dispatch
>+ functions for this MMI source.
>+ @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
>+**/
>+typedef
>+EFI_STATUS
>+(EFIAPI *EFI_MM_USB_UNREGISTER)(
>+ IN CONST EFI_MM_USB_DISPATCH_PROTOCOL *This,
>+ IN EFI_HANDLE DispatchHandle
>+ );
>+
>+///
>+/// Interface structure for the MM USB MMI Dispatch Protocol
>+///
>+/// This protocol provides the parent dispatch service for the USB MMI
>source generator.
>+///
>+struct _EFI_MM_USB_DISPATCH_PROTOCOL {
>+ EFI_MM_USB_REGISTER Register;
>+ EFI_MM_USB_UNREGISTER UnRegister;
>+};
>+
>+extern EFI_GUID gEfiMmUsbDispatchProtocolGuid;
>+
>+#endif
>+
>diff --git a/MdePkg/MdePkg.dec b/MdePkg/MdePkg.dec
>index f54b056..ace4df3 100644
>--- a/MdePkg/MdePkg.dec
>+++ b/MdePkg/MdePkg.dec
>@@ -1033,6 +1033,9 @@
> ## Include/Protocol/SmmReportStatusCodeHandler.h
> gEfiSmmRscHandlerProtocolGuid = { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3,
>0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }}
>
>+ ## Include/Protocol/MmReportStatusCodeHandler.h
>+ gEfiMmRscHandlerProtocolGuid = { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3,
>0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }}
>+
> ## Include/Protocol/AcpiSystemDescriptionTable.h
> gEfiAcpiSdtProtocolGuid = { 0xeb97088e, 0xcfdf, 0x49c6, { 0xbe, 0x4b,
>0xd9, 0x6, 0xa5, 0xb2, 0xe, 0x86 }}
>
>@@ -1042,60 +1045,117 @@
> ## Include/Protocol/SmmCpuIo2.h
> gEfiSmmCpuIo2ProtocolGuid = { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95, 0x5d,
>0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }}
>
>+ ## Include/Protocol/MmCpuIo.h
>+ gEfiMmCpuIoProtocolGuid = { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95, 0x5d,
>0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }}
>+
> ## Include/Protocol/SmmBase2.h
> gEfiSmmBase2ProtocolGuid = { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, 0xd4,
>0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }}
>
>+ ## Include/Protocol/MmBase.h
>+ gEfiMmBaseProtocolGuid = { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, 0xd4,
>0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }}
>+
> ## Include/Protocol/SmmAccess2.h
> gEfiSmmAccess2ProtocolGuid = { 0xc2702b74, 0x800c, 0x4131, { 0x87, 0x46,
>0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }}
>
>+ ## Include/Protocol/MmAccess.h
>+ gEfiMmAccessProtocolGuid = { 0xc2702b74, 0x800c, 0x4131, { 0x87, 0x46,
>0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }}
>+
> ## Include/Protocol/SmmControl2.h
> gEfiSmmControl2ProtocolGuid = { 0x843dc720, 0xab1e, 0x42cb, { 0x93, 0x57,
>0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}}
>
>+ ## Include/Protocol/MmControl.h
>+ gEfiMmControlProtocolGuid = { 0x843dc720, 0xab1e, 0x42cb, { 0x93, 0x57,
>0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}}
>+
> ## Include/Protocol/SmmConfiguration.h
> gEfiSmmConfigurationProtocolGuid= { 0x26eeb3de, 0xb689, 0x492e, { 0x80,
>0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }}
>
>+ ## Include/Protocol/MmConfiguration.h
>+ gEfiMmConfigurationProtocolGuid= { 0x26eeb3de, 0xb689, 0x492e, { 0x80,
>0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }}
>+
> ## Include/Protocol/SmmReadyToLock.h
> gEfiSmmReadyToLockProtocolGuid = { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82,
>0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }}
>
>+ ## Include/Protocol/MmReadyToLock.h
>+ gEfiMmReadyToLockProtocolGuid = { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82,
>0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }}
>+
> ## Include/Protocol/DxeSmmReadyToLock.h
> gEfiDxeSmmReadyToLockProtocolGuid = { 0x60ff8964, 0xe906, 0x41d0, { 0xaf,
>0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }}
>
>+ ## Include/Protocol/DxeMmReadyToLock.h
>+ gEfiDxeMmReadyToLockProtocolGuid = { 0x60ff8964, 0xe906, 0x41d0, { 0xaf,
>0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }}
>+
> ## Include/Protocol/SmmCommunication.h
> gEfiSmmCommunicationProtocolGuid = { 0xc68ed8e2, 0x9dc6, 0x4cbd,
>{ 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }}
>
>+ ## Include/Protocol/MmCommunication.h
>+ gEfiMmCommunicationProtocolGuid = { 0xc68ed8e2, 0x9dc6, 0x4cbd,
>{ 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }}
>+
> ## Include/Protocol/SmmStatusCode.h
> gEfiSmmStatusCodeProtocolGuid = { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6,
>0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}}
>
>+ ## Include/Protocol/MmStatusCode.h
>+ gEfiMmStatusCodeProtocolGuid = { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6,
>0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}}
>+
> ## Include/Protocol/SmmCpu.h
> gEfiSmmCpuProtocolGuid = { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22,
>0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }}
>
>+ ## Include/Protocol/MmCpu.h
>+ gEfiMmCpuProtocolGuid = { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22,
>0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }}
>+
> ## Include/Protocol/SmmPciRootBridgeIo.h
> gEfiSmmPciRootBridgeIoProtocolGuid = { 0x8bc1714d, 0xffcb, 0x41c3, { 0x89,
>0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }}
>
>+ ## Include/Protocol/MmPciRootBridgeIo.h
>+ gEfiMmPciRootBridgeIoProtocolGuid = { 0x8bc1714d, 0xffcb, 0x41c3, { 0x89,
>0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }}
>+
> ## Include/Protocol/SmmSwDispatch2.h
> gEfiSmmSwDispatch2ProtocolGuid = { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1,
>0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }}
>
>+ ## Include/Protocol/MmSwDispatch.h
>+ gEfiMmSwDispatchProtocolGuid = { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1,
>0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }}
>+
> ## Include/Protocol/SmmSxDispatch2.h
> gEfiSmmSxDispatch2ProtocolGuid = { 0x456d2859, 0xa84b, 0x4e47, {0xa2,
>0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }}
>
>+ ## Include/Protocol/MmSxDispatch.h
>+ gEfiMmSxDispatchProtocolGuid = { 0x456d2859, 0xa84b, 0x4e47, {0xa2,
>0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }}
>+
> ## Include/Protocol/SmmPeriodicTimerDispatch2.h
> gEfiSmmPeriodicTimerDispatch2ProtocolGuid = { 0x4cec368e, 0x8e8e,
>0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }}
>
>+ ## Include/Protocol/MmPeriodicTimerDispatch.h
>+ gEfiMmPeriodicTimerDispatchProtocolGuid = { 0x4cec368e, 0x8e8e, 0x4d71,
>{0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }}
>+
> ## Include/Protocol/SmmUsbDispatch2.h
> gEfiSmmUsbDispatch2ProtocolGuid = { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd,
>0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }}
>
>+ ## Include/Protocol/MmUsbDispatch.h
>+ gEfiMmUsbDispatchProtocolGuid = { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd,
>0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }}
>+
> ## Include/Protocol/SmmGpiDispatch2.h
> gEfiSmmGpiDispatch2ProtocolGuid = { 0x25566b03, 0xb577, 0x4cbf, {0x95,
>0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }}
>
>+ ## Include/Protocol/MmGpiDispatch.h
>+ gEfiMmGpiDispatchProtocolGuid = { 0x25566b03, 0xb577, 0x4cbf, {0x95,
>0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }}
>+
> ## Include/Protocol/SmmStandbyButtonDispatch2.h
> gEfiSmmStandbyButtonDispatch2ProtocolGuid = { 0x7300c4a1, 0x43f2,
>0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }}
>
>+ ## Include/Protocol/MmStandbyButtonDispatch.h
>+ gEfiMmStandbyButtonDispatchProtocolGuid = { 0x7300c4a1, 0x43f2, 0x4017,
>{0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }}
>+
> ## Include/Protocol/SmmPowerButtonDispatch2.h
> gEfiSmmPowerButtonDispatch2ProtocolGuid = { 0x1b1183fa, 0x1823, 0x46a7,
>{0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }}
>
>+ ## Include/Protocol/MmPowerButtonDispatch.h
>+ gEfiMmPowerButtonDispatchProtocolGuid = { 0x1b1183fa, 0x1823, 0x46a7,
>{0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }}
>+
> ## Include/Protocol/SmmIoTrapDispatch2.h
> gEfiSmmIoTrapDispatch2ProtocolGuid = { 0x58dc368d, 0x7bfa, 0x4e77, {0xab,
>0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }}
>
>+ ## Include/Protocol/MmIoTrapDispatch.h
>+ gEfiMmIoTrapDispatchProtocolGuid = { 0x58dc368d, 0x7bfa, 0x4e77, {0xab,
>0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }}
>+
> ## Include/Protocol/PiPcd.h
> gEfiPcdProtocolGuid = { 0x13a3f0f6, 0x264a, 0x3ef0, { 0xf2, 0xe0, 0xde, 0xc5,
>0x12, 0x34, 0x2f, 0x34 } }
>
>@@ -1141,6 +1201,9 @@
> ## Include/Protocol/SmmEndOfDxe.h
> gEfiSmmEndOfDxeProtocolGuid = { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39,
>0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }}
>
>+ ## Include/Protocol/MmEndOfDxe.h
>+ gEfiMmEndOfDxeProtocolGuid = { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39,
>0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }}
>+
> ## Include/Protocol/IsaHc.h
> gEfiIsaHcProtocolGuid = { 0xbcdaf080, 0x1bde, 0x4e22, {0xae, 0x6a,
>0x43, 0x54, 0x1e, 0x12, 0x8e, 0xc4 } }
> gEfiIsaHcServiceBindingProtocolGuid = { 0xfad7933a, 0x6c21, 0x4234, {0xa4,
>0x34, 0x0a, 0x8a, 0x0d, 0x2b, 0x07, 0x81 } }
>--
>2.7.0.windows.1
_______________________________________________
edk2-devel mailing list
edk2-devel@lists.01.org
https://lists.01.org/mailman/listinfo/edk2-devel
© 2016 - 2024 Red Hat, Inc.