tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
Reviewed-by: Liming Gao <liming.gao@intel.com>
This commit is contained in:
Eric Dong 2017-08-28 14:20:31 +08:00
parent 47bfbd7f80
commit 07c6a47e70
24 changed files with 2618 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

350
MdePkg/Include/Pi/PiMmCis.h Normal file
View File

@ -0,0 +1,350 @@
/** @file
Common definitions in the Platform Initialization Specification version 1.5
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 MM 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 MM.
///
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 MM 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 MmConfigurationTable.
///
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

25
MdePkg/Include/PiMm.h Normal file
View File

@ -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

25
MdePkg/Include/Protocol/DxeMmReadyToLock.h Normal file
View File

@ -0,0 +1,25 @@
/** @file
DXE MM Ready To Lock protocol introduced in the PI 1.5 specification.
Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#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

133
MdePkg/Include/Protocol/MmAccess.h Normal file
View File

@ -0,0 +1,133 @@
/** @file
EFI MM Access Protocol as defined in the PI 1.5 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) 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

87
MdePkg/Include/Protocol/MmBase.h Normal file
View File

@ -0,0 +1,87 @@
/** @file
EFI MM Base Protocol as defined in the PI 1.5 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) 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

83
MdePkg/Include/Protocol/MmCommunication.h Normal file
View File

@ -0,0 +1,83 @@
/** @file
EFI MM Communication Protocol as defined in the PI 1.5 specification.
This protocol provides a means of communicating between drivers outside of MM and MMI
handlers inside of MM.
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 _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

86
MdePkg/Include/Protocol/MmConfiguration.h Normal file
View File

@ -0,0 +1,86 @@
/** @file
EFI MM Configuration Protocol as defined in the PI 1.5 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) 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

106
MdePkg/Include/Protocol/MmControl.h Normal file
View File

@ -0,0 +1,106 @@
/** @file
EFI MM Control Protocol as defined in the PI 1.5 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) 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

247
MdePkg/Include/Protocol/MmCpu.h Normal file
View File

@ -0,0 +1,247 @@
/** @file
EFI MM CPU Protocol as defined in the PI 1.5 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) 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

96
MdePkg/Include/Protocol/MmCpuIo.h Normal file
View File

@ -0,0 +1,96 @@
/** @file
MM CPU I/O 2 protocol as defined in the PI 1.5 specification.
This protocol provides CPU I/O and memory access within MM.
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 _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

30
MdePkg/Include/Protocol/MmEndOfDxe.h Normal file
View File

@ -0,0 +1,30 @@
/** @file
MM End Of Dxe protocol introduced in the PI 1.5 specification.
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) 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

125
MdePkg/Include/Protocol/MmGpiDispatch.h Normal file
View File

@ -0,0 +1,125 @@
/** @file
MM General Purpose Input (GPI) Dispatch Protocol as defined in PI 1.5 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) 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.5.
**/
#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

136
MdePkg/Include/Protocol/MmIoTrapDispatch.h Normal file
View File

@ -0,0 +1,136 @@
/** @file
MM IO Trap Dispatch Protocol as defined in PI 1.5 Specification
Volume 4 Management Mode Core Interface.
This protocol provides a parent dispatch service for IO trap MMI sources.
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.
@par Revision Reference:
This protocol is from PI Version 1.5.
**/
#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

37
MdePkg/Include/Protocol/MmPciRootBridgeIo.h Normal file
View File

@ -0,0 +1,37 @@
/** @file
MM PCI Root Bridge IO protocol as defined in the PI 1.5 specification.
This protocol provides PCI I/O and memory access within MM.
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 _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

170
MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h Normal file
View File

@ -0,0 +1,170 @@
/** @file
MM Periodic Timer Dispatch Protocol as defined in PI 1.5 Specification
Volume 4 Management Mode Core Interface.
This protocol provides the parent dispatch service for the periodical timer MMI source generator.
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.
@par Revision Reference:
This protocol is from PI Version 1.5.
**/
#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

117
MdePkg/Include/Protocol/MmPowerButtonDispatch.h Normal file
View File

@ -0,0 +1,117 @@
/** @file
MM Power Button Dispatch Protocol as defined in PI 1.5 Specification
Volume 4 Management Mode Core Interface.
This protocol provides the parent dispatch service for the power button MMI source generator.
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.
@par Revision Reference:
This protocol is from PI Version 1.5.
**/
#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

32
MdePkg/Include/Protocol/MmReadyToLock.h Normal file
View File

@ -0,0 +1,32 @@
/** @file
MM Ready To Lock protocol introduced in the PI 1.5 specification.
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) 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

81
MdePkg/Include/Protocol/MmReportStatusCodeHandler.h Normal file
View File

@ -0,0 +1,81 @@
/** @file
This protocol provides registering and unregistering services to status code consumers while in DXE MM.
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 __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

119
MdePkg/Include/Protocol/MmStandbyButtonDispatch.h Normal file
View File

@ -0,0 +1,119 @@
/** @file
MM Standby Button Dispatch Protocol as defined in PI 1.5 Specification
Volume 4 Management Mode Core Interface.
This protocol provides the parent dispatch service for the standby button MMI source generator.
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.
@par Revision Reference:
This protocol is from PI Version 1.5.
**/
#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

65
MdePkg/Include/Protocol/MmStatusCode.h Normal file
View File

@ -0,0 +1,65 @@
/** @file
EFI MM Status Code Protocol as defined in the PI 1.5 specification.
This protocol provides the basic status code services while in MM.
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 _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

136
MdePkg/Include/Protocol/MmSwDispatch.h Normal file
View File

@ -0,0 +1,136 @@
/** @file
MM Software Dispatch Protocol introduced from PI 1.5 Specification
Volume 4 Management Mode Core Interface.
This protocol provides the parent dispatch service for a given MMI source generator.
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 _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

135
MdePkg/Include/Protocol/MmSxDispatch.h Normal file
View File

@ -0,0 +1,135 @@
/** @file
MM Sx Dispatch Protocol as defined in PI 1.5 Specification
Volume 4 Management Mode Core Interface.
Provides the parent dispatch service for a given Sx-state source generator.
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 _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

130
MdePkg/Include/Protocol/MmUsbDispatch.h Normal file
View File

@ -0,0 +1,130 @@
/** @file
MM USB Dispatch Protocol as defined in PI 1.5 Specification
Volume 4 Management Mode Core Interface.
Provides the parent dispatch service for the USB MMI source generator.
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.
@par Revision Reference:
This protocol is from PI Version 1.5.
**/
#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

67
MdePkg/MdePkg.dec
View File

@ -1178,6 +1178,73 @@
## Include/Protocol/I2cBusConfigurationManagement.h
gEfiI2cBusConfigurationManagementProtocolGuid = { 0x55b71fb5, 0x17c6, 0x410e, { 0xb5, 0xbd, 0x5f, 0xa2, 0xe3, 0xd4, 0x46, 0x6b }}
#
# Protocols defined in PI 1.5.
#
## Include/Protocol/MmEndOfDxe.h
gEfiMmEndOfDxeProtocolGuid = { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }}
## Include/Protocol/MmIoTrapDispatch.h
gEfiMmIoTrapDispatchProtocolGuid = { 0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }}
## Include/Protocol/MmPowerButtonDispatch.h
gEfiMmPowerButtonDispatchProtocolGuid = { 0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }}
## Include/Protocol/MmStandbyButtonDispatch.h
gEfiMmStandbyButtonDispatchProtocolGuid = { 0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }}
## Include/Protocol/MmGpiDispatch.h
gEfiMmGpiDispatchProtocolGuid = { 0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }}
## Include/Protocol/MmUsbDispatch.h
gEfiMmUsbDispatchProtocolGuid = { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }}
## Include/Protocol/MmPeriodicTimerDispatch.h
gEfiMmPeriodicTimerDispatchProtocolGuid = { 0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }}
## Include/Protocol/MmSxDispatch.h
gEfiMmSxDispatchProtocolGuid = { 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }}
## Include/Protocol/MmSwDispatch.h
gEfiMmSwDispatchProtocolGuid = { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }}
## Include/Protocol/MmPciRootBridgeIo.h
gEfiMmPciRootBridgeIoProtocolGuid = { 0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }}
## Include/Protocol/MmCpu.h
gEfiMmCpuProtocolGuid = { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }}
## Include/Protocol/MmStatusCode.h
gEfiMmStatusCodeProtocolGuid = { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}}
## Include/Protocol/DxeMmReadyToLock.h
gEfiDxeMmReadyToLockProtocolGuid = { 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }}
## Include/Protocol/MmConfiguration.h
gEfiMmConfigurationProtocolGuid= { 0x26eeb3de, 0xb689, 0x492e, { 0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }}
## Include/Protocol/MmReadyToLock.h
gEfiMmReadyToLockProtocolGuid = { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }}
## Include/Protocol/MmControl.h
gEfiMmControlProtocolGuid = { 0x843dc720, 0xab1e, 0x42cb, { 0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}}
## Include/Protocol/MmAccess.h
gEfiMmAccessProtocolGuid = { 0xc2702b74, 0x800c, 0x4131, { 0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }}
## Include/Protocol/MmBase.h
gEfiMmBaseProtocolGuid = { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }}
## Include/Protocol/MmCpuIo.h
gEfiMmCpuIoProtocolGuid = { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95, 0x5d, 0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }}
## Include/Protocol/MmReportStatusCodeHandler.h
gEfiMmRscHandlerProtocolGuid = { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }}
## Include/Protocol/MmCommunication.h
gEfiMmCommunicationProtocolGuid = { 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }}
#
# Protocols defined in UEFI2.1/UEFI2.0/EFI1.1
#