tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-04-07 19:45:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

MdePkg: Reference new definitions for Management Mode.

Browse Source 
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 update the original files which
related to old SMM modules, also keep the compatible with old SMM
related drivers.

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:35:08 +08:00
parent 07c6a47e70
commit 2f208e59e4
23 changed files with 248 additions and 1351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
MdePkg/Include/Pi/PiMultiPhase.h
View File

@ -95,43 +95,49 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
///@}
///
/// SMRAM states and capabilities
/// MMRAM states and capabilities
///
#define EFI_SMRAM_OPEN 0x00000001
#define EFI_SMRAM_CLOSED 0x00000002
#define EFI_SMRAM_LOCKED 0x00000004
#define EFI_MMRAM_OPEN 0x00000001
#define EFI_MMRAM_CLOSED 0x00000002
#define EFI_MMRAM_LOCKED 0x00000004
#define EFI_CACHEABLE 0x00000008
#define EFI_ALLOCATED 0x00000010
#define EFI_NEEDS_TESTING 0x00000020
#define EFI_NEEDS_ECC_INITIALIZATION 0x00000040
#define EFI_SMRAM_OPEN EFI_MMRAM_OPEN
#define EFI_SMRAM_CLOSED EFI_MMRAM_CLOSED
#define EFI_SMRAM_LOCKED EFI_MMRAM_LOCKED
///
/// Structure describing a SMRAM region and its accessibility attributes.
/// Structure describing a MMRAM region and its accessibility attributes.
///
typedef struct {
///
/// Designates the physical address of the SMRAM in memory. This view of memory is
/// the same as seen by I/O-based agents, for example, but it may not be the address seen
/// Designates the physical address of the MMRAM in memory. This view of memory is
/// the same as seen by I/O-based agents, for example, but it may not be the address seen
/// by the processors.
///
EFI_PHYSICAL_ADDRESS PhysicalStart;
///
/// Designates the address of the SMRAM, as seen by software executing on the
/// Designates the address of the MMRAM, as seen by software executing on the
/// processors. This address may or may not match PhysicalStart.
///
EFI_PHYSICAL_ADDRESS CpuStart;
///
/// Describes the number of bytes in the SMRAM region.
/// Describes the number of bytes in the MMRAM region.
///
UINT64 PhysicalSize;
///
/// Describes the accessibility attributes of the SMRAM. These attributes include the
/// hardware state (e.g., Open/Closed/Locked), capability (e.g., cacheable), logical
/// allocation (e.g., allocated), and pre-use initialization (e.g., needs testing/ECC
/// Describes the accessibility attributes of the MMRAM. These attributes include the
/// hardware state (e.g., Open/Closed/Locked), capability (e.g., cacheable), logical
/// allocation (e.g., allocated), and pre-use initialization (e.g., needs testing/ECC
/// initialization).
///
UINT64 RegionState;
} EFI_SMRAM_DESCRIPTOR;
} EFI_MMRAM_DESCRIPTOR;
typedef EFI_MMRAM_DESCRIPTOR EFI_SMRAM_DESCRIPTOR;
typedef enum {
EFI_PCD_TYPE_8,

183
MdePkg/Include/Pi/PiSmmCis.h
View File

@ -16,21 +16,17 @@
#ifndef _PI_SMMCIS_H_
#define _PI_SMMCIS_H_
#include <Pi/PiMultiPhase.h>
#include <Pi/PiMmCis.h>
#include <Protocol/SmmCpuIo2.h>
typedef struct _EFI_SMM_SYSTEM_TABLE2 EFI_SMM_SYSTEM_TABLE2;
///
/// The System Management System Table (SMST) signature
///
#define SMM_SMST_SIGNATURE SIGNATURE_32 ('S', 'M', 'S', 'T')
///
/// The System Management System Table (SMST) revision is 1.4
///
#define SMM_SPECIFICATION_MAJOR_REVISION 1
#define SMM_SPECIFICATION_MINOR_REVISION 40
#define EFI_SMM_SYSTEM_TABLE2_REVISION ((SMM_SPECIFICATION_MAJOR_REVISION<<16) | (SMM_SPECIFICATION_MINOR_REVISION))
//
// Define new MM related definition introduced by PI 1.5.
//
#define SMM_SMST_SIGNATURE MM_MMST_SIGNATURE
#define SMM_SPECIFICATION_MAJOR_REVISION MM_SPECIFICATION_MAJOR_REVISION
#define SMM_SPECIFICATION_MINOR_REVISION MM_SPECIFICATION_MINOR_REVISION
#define EFI_SMM_SYSTEM_TABLE2_REVISION EFI_MM_SYSTEM_TABLE_REVISION
/**
Adds, updates, or removes a configuration table entry from the System Management System Table.
@ -53,160 +49,19 @@ typedef struct _EFI_SMM_SYSTEM_TABLE2 EFI_SMM_SYSTEM_TABLE2;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INSTALL_CONFIGURATION_TABLE2)(
IN CONST EFI_SMM_SYSTEM_TABLE2 *SystemTable,
IN CONST EFI_GUID *Guid,
IN VOID *Table,
IN UINTN TableSize
IN CONST EFI_SMM_SYSTEM_TABLE2 *SystemTable,
IN CONST EFI_GUID *Guid,
IN VOID *Table,
IN UINTN TableSize
);
/**
This service lets the caller to get one distinct application processor (AP) to execute
a caller-provided code stream while in SMM.
@param[in] Procedure A pointer to the code stream to be run on the designated
AP of the system.
@param[in] CpuNumber The zero-based index of the processor number of the AP
on which the code stream is supposed to run.
@param[in,out] ProcArguments Allows the caller to pass a list of parameters to the code
that is run by the AP.
@retval EFI_SUCCESS The call was successful and the return parameters are valid.
@retval EFI_INVALID_PARAMETER The input arguments are out of range.
@retval EFI_INVALID_PARAMETER The CPU requested is not available on this SMI invocation.
@retval EFI_INVALID_PARAMETER The CPU cannot support an additional service invocation.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STARTUP_THIS_AP)(
IN EFI_AP_PROCEDURE Procedure,
IN UINTN CpuNumber,
IN OUT VOID *ProcArguments OPTIONAL
);
/**
Function prototype for protocol install notification.
@param[in] Protocol Points to the protocol's unique identifier.
@param[in] Interface Points to the interface instance.
@param[in] Handle The handle on which the interface was installed.
@return Status Code
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_NOTIFY_FN)(
IN CONST EFI_GUID *Protocol,
IN VOID *Interface,
IN EFI_HANDLE Handle
);
/**
Register a callback function be called when a particular protocol interface is installed.
The SmmRegisterProtocolNotify() function creates a registration Function that is to be
called whenever a protocol interface is installed for Protocol by
SmmInstallProtocolInterface().
If Function == NULL and Registration is an existing registration, then the callback is unhooked.
@param[in] Protocol The unique ID of the protocol for which the event is to be registered.
@param[in] Function Points to the notification function.
@param[out] Registration A pointer to a memory location to receive the registration value.
@retval EFI_SUCCESS Successfully returned the registration record
that has been added or unhooked.
@retval EFI_INVALID_PARAMETER Protocol is NULL or Registration is NULL.
@retval EFI_OUT_OF_RESOURCES Not enough memory resource to finish the request.
@retval EFI_NOT_FOUND If the registration is not found when Function == NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_REGISTER_PROTOCOL_NOTIFY)(
IN CONST EFI_GUID *Protocol,
IN EFI_SMM_NOTIFY_FN Function,
OUT VOID **Registration
);
/**
Manage SMI of a particular type.
@param[in] HandlerType Points to the handler type or NULL for root SMI handlers.
@param[in] Context Points to an optional context buffer.
@param[in,out] CommBuffer Points to the optional communication buffer.
@param[in,out] CommBufferSize Points to the size of the optional communication buffer.
@retval EFI_WARN_INTERRUPT_SOURCE_PENDING Interrupt source was processed successfully but not quiesced.
@retval EFI_INTERRUPT_PENDING One or more SMI sources could not be quiesced.
@retval EFI_NOT_FOUND Interrupt source was not handled or quiesced.
@retval EFI_SUCCESS Interrupt source was handled and quiesced.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INTERRUPT_MANAGE)(
IN CONST EFI_GUID *HandlerType,
IN CONST VOID *Context OPTIONAL,
IN OUT VOID *CommBuffer OPTIONAL,
IN OUT UINTN *CommBufferSize OPTIONAL
);
/**
Main entry point for an SMM handler dispatch or communicate-based callback.
@param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
@param[in] Context Points to an optional handler context which was specified when the
handler was registered.
@param[in,out] CommBuffer A pointer to a collection of data in memory that will
be conveyed from a non-SMM environment into an SMM environment.
@param[in,out] CommBufferSize The size of the CommBuffer.
@retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers
should still be called.
@retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should
still be called.
@retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still
be called.
@retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT2)(
IN EFI_HANDLE DispatchHandle,
IN CONST VOID *Context OPTIONAL,
IN OUT VOID *CommBuffer OPTIONAL,
IN OUT UINTN *CommBufferSize OPTIONAL
);
/**
Registers a handler to execute within SMM.
@param[in] Handler Handler service function pointer.
@param[in] HandlerType Points to the handler type or NULL for root SMI handlers.
@param[out] DispatchHandle On return, contains a unique handle which can be used to later
unregister the handler function.
@retval EFI_SUCCESS SMI handler added successfully.
@retval EFI_INVALID_PARAMETER Handler is NULL or DispatchHandle is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INTERRUPT_REGISTER)(
IN EFI_SMM_HANDLER_ENTRY_POINT2 Handler,
IN CONST EFI_GUID *HandlerType OPTIONAL,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregister a handler in SMM.
@param[in] DispatchHandle The handle that was specified when the handler was registered.
@retval EFI_SUCCESS Handler function was successfully unregistered.
@retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INTERRUPT_UNREGISTER)(
IN EFI_HANDLE DispatchHandle
);
typedef EFI_MM_STARTUP_THIS_AP EFI_SMM_STARTUP_THIS_AP;
typedef EFI_MM_NOTIFY_FN EFI_SMM_NOTIFY_FN;
typedef EFI_MM_REGISTER_PROTOCOL_NOTIFY EFI_SMM_REGISTER_PROTOCOL_NOTIFY;
typedef EFI_MM_INTERRUPT_MANAGE EFI_SMM_INTERRUPT_MANAGE;
typedef EFI_MM_HANDLER_ENTRY_POINT EFI_SMM_HANDLER_ENTRY_POINT2;
typedef EFI_MM_INTERRUPT_REGISTER EFI_SMM_INTERRUPT_REGISTER;
typedef EFI_MM_INTERRUPT_UNREGISTER EFI_SMM_INTERRUPT_UNREGISTER;
///
/// Processor information and functionality needed by SMM Foundation.

9
MdePkg/Include/Protocol/DxeSmmReadyToLock.h
View File

@ -17,7 +17,7 @@
platform code may choose to use notification handler to lock SMM by invoking
EFI_SMM_ACCESS2_PROTOCOL.Lock() function.
Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -31,10 +31,9 @@
#ifndef _DXE_SMM_READY_TO_LOCK_H_
#define _DXE_SMM_READY_TO_LOCK_H_
#define EFI_DXE_SMM_READY_TO_LOCK_PROTOCOL_GUID \
{ \
0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e } \
}
#include <Protocol/DxeMmReadyToLock.h>
#define EFI_DXE_SMM_READY_TO_LOCK_PROTOCOL_GUID EFI_DXE_MM_READY_TO_LOCK_PROTOCOL_GUID
extern EFI_GUID gEfiDxeSmmReadyToLockProtocolGuid;

103
MdePkg/Include/Protocol/SmmAccess2.h
View File

@ -25,108 +25,19 @@
#ifndef _SMM_ACCESS2_H_
#define _SMM_ACCESS2_H_
#define EFI_SMM_ACCESS2_PROTOCOL_GUID \
{ \
0xc2702b74, 0x800c, 0x4131, {0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac } \
}
#include <Protocol/MmAccess.h>
#define EFI_SMM_ACCESS2_PROTOCOL_GUID EFI_MM_ACCESS_PROTOCOL_GUID
typedef struct _EFI_SMM_ACCESS2_PROTOCOL EFI_SMM_ACCESS2_PROTOCOL;
typedef EFI_MM_ACCESS_PROTOCOL EFI_SMM_ACCESS2_PROTOCOL;
/**
Opens the SMRAM area to be accessible by a boot-service driver.
typedef EFI_MM_OPEN EFI_SMM_OPEN2;
This function "opens" SMRAM so that it is visible while not inside of SMM. The function should
return EFI_UNSUPPORTED if the hardware does not support hiding of SMRAM. The function
should return EFI_DEVICE_ERROR if the SMRAM configuration is locked.
typedef EFI_MM_CLOSE EFI_SMM_CLOSE2;
@param[in] This The EFI_SMM_ACCESS2_PROTOCOL instance.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_UNSUPPORTED The system does not support opening and closing of SMRAM.
@retval EFI_DEVICE_ERROR SMRAM cannot be opened, perhaps because it is locked.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_OPEN2)(
IN EFI_SMM_ACCESS2_PROTOCOL *This
);
/**
Inhibits access to the SMRAM.
This function "closes" SMRAM so that it is not visible while outside of SMM. The function should
return EFI_UNSUPPORTED if the hardware does not support hiding of SMRAM.
@param[in] This The EFI_SMM_ACCESS2_PROTOCOL instance.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_UNSUPPORTED The system does not support opening and closing of SMRAM.
@retval EFI_DEVICE_ERROR SMRAM cannot be closed.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CLOSE2)(
IN EFI_SMM_ACCESS2_PROTOCOL *This
);
/**
Inhibits access to the SMRAM.
This function prohibits access to the SMRAM region. This function is usually implemented such
that it is a write-once operation.
@param[in] This The EFI_SMM_ACCESS2_PROTOCOL instance.
@retval EFI_SUCCESS The device was successfully locked.
@retval EFI_UNSUPPORTED The system does not support locking of SMRAM.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_LOCK2)(
IN EFI_SMM_ACCESS2_PROTOCOL *This
);
/**
Queries the memory controller for the possible regions that will support SMRAM.
@param[in] This The EFI_SMM_ACCESS2_PROTOCOL instance.
@param[in,out] SmramMapSize A pointer to the size, in bytes, of the SmramMemoryMap buffer.
@param[in,out] SmramMap A pointer to the buffer in which firmware places the current memory map.
@retval EFI_SUCCESS The chipset supported the given resource.
@retval EFI_BUFFER_TOO_SMALL The SmramMap parameter was too small. The current buffer size
needed to hold the memory map is returned in SmramMapSize.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CAPABILITIES2)(
IN CONST EFI_SMM_ACCESS2_PROTOCOL *This,
IN OUT UINTN *SmramMapSize,
IN OUT EFI_SMRAM_DESCRIPTOR *SmramMap
);
///
/// EFI SMM Access2 Protocol is used to control the visibility of the SMRAM on the platform.
/// It abstracts the location and characteristics of SMRAM. The 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_SMM_ACCESS2_PROTOCOL {
EFI_SMM_OPEN2 Open;
EFI_SMM_CLOSE2 Close;
EFI_SMM_LOCK2 Lock;
EFI_SMM_CAPABILITIES2 GetCapabilities;
///
/// Indicates the current state of the SMRAM. Set to TRUE if SMRAM is locked.
///
BOOLEAN LockState;
///
/// Indicates the current state of the SMRAM. Set to TRUE if SMRAM is open.
///
BOOLEAN OpenState;
};
typedef EFI_MM_LOCK EFI_SMM_LOCK2;
typedef EFI_MM_CAPABILITIES EFI_SMM_CAPABILITIES2;
extern EFI_GUID gEfiSmmAccess2ProtocolGuid;
#endif

8
MdePkg/Include/Protocol/SmmBase2.h
View File

@ -4,7 +4,7 @@
This protocol is utilized by all SMM drivers to locate the SMM infrastructure services and determine
whether the driver is being invoked inside SMRAM or outside of SMRAM.
Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -19,11 +19,9 @@
#define _SMM_BASE2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmBase.h>
#define EFI_SMM_BASE2_PROTOCOL_GUID \
{ \
0xf4ccbfb7, 0xf6e0, 0x47fd, {0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 } \
}
#define EFI_SMM_BASE2_PROTOCOL_GUID EFI_MM_BASE_PROTOCOL_GUID
typedef struct _EFI_SMM_BASE2_PROTOCOL EFI_SMM_BASE2_PROTOCOL;

58
MdePkg/Include/Protocol/SmmCommunication.h
View File

@ -18,64 +18,14 @@
#ifndef _SMM_COMMUNICATION_H_
#define _SMM_COMMUNICATION_H_
#pragma pack(1)
#include <Protocol/MmCommunication.h>
///
/// To avoid confusion in interpreting frames, the communication buffer should always
/// begin with EFI_SMM_COMMUNICATE_HEADER
///
typedef struct {
///
/// Allows for disambiguation of the message format.
///
EFI_GUID HeaderGuid;
///
/// Describes the size of Data (in bytes) and does not include the size of the header.
///
UINTN MessageLength;
///
/// Designates an array of bytes that is MessageLength in size.
///
UINT8 Data[1];
} EFI_SMM_COMMUNICATE_HEADER;
#pragma pack()
typedef EFI_MM_COMMUNICATE_HEADER EFI_SMM_COMMUNICATE_HEADER;
#define EFI_SMM_COMMUNICATION_PROTOCOL_GUID \
{ \
0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 } \
}
#define EFI_SMM_COMMUNICATION_PROTOCOL_GUID EFI_MM_COMMUNICATION_PROTOCOL_GUID
typedef struct _EFI_SMM_COMMUNICATION_PROTOCOL EFI_SMM_COMMUNICATION_PROTOCOL;
/**
Communicates with a registered handler.
This function provides a service to send and receive messages from a registered UEFI service.
@param[in] This The EFI_SMM_COMMUNICATION_PROTOCOL instance.
@param[in] CommBuffer A pointer to the buffer to convey into SMRAM.
@param[in] CommSize The size of the data buffer being passed in.On exit, the size of data
being returned. Zero if the handler does not wish to reply with any data.
@retval EFI_SUCCESS The message was successfully posted.
@retval EFI_INVALID_PARAMETER The CommBuffer was NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_COMMUNICATE2)(
IN CONST EFI_SMM_COMMUNICATION_PROTOCOL *This,
IN OUT VOID *CommBuffer,
IN OUT UINTN *CommSize
);
///
/// EFI SMM Communication Protocol provides runtime services for communicating
/// between DXE drivers and a registered SMI handler.
///
struct _EFI_SMM_COMMUNICATION_PROTOCOL {
EFI_SMM_COMMUNICATE2 Communicate;
};
typedef EFI_MM_COMMUNICATION_PROTOCOL EFI_SMM_COMMUNICATION_PROTOCOL;
extern EFI_GUID gEfiSmmCommunicationProtocolGuid;

8
MdePkg/Include/Protocol/SmmConfiguration.h
View File

@ -6,7 +6,7 @@
2) register the SMM Foundation entry point with the processor code. The entry
point will be invoked by the SMM processor entry code.
Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -20,12 +20,10 @@
#ifndef _SMM_CONFIGURATION_H_
#define _SMM_CONFIGURATION_H_
#include <Protocol/MmConfiguration.h>
#include <Pi/PiSmmCis.h>
#define EFI_SMM_CONFIGURATION_PROTOCOL_GUID \
{ \
0x26eeb3de, 0xb689, 0x492e, {0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 } \
}
#define EFI_SMM_CONFIGURATION_PROTOCOL_GUID EFI_MM_CONFIGURATION_PROTOCOL_GUID
///
/// Structure describing a SMRAM region which cannot be used for the SMRAM heap.

79
MdePkg/Include/Protocol/SmmControl2.h
View File

@ -11,7 +11,7 @@
accessed, will generate the SMI. Also, the hardware optionally supports the periodic generation of
these signals.
Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -25,81 +25,16 @@
#ifndef _SMM_CONTROL2_H_
#define _SMM_CONTROL2_H_
#include <PiDxe.h>
#include <Protocol/MmControl.h>
#define EFI_SMM_CONTROL2_PROTOCOL_GUID \
{ \
0x843dc720, 0xab1e, 0x42cb, {0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b} \
}
#define EFI_SMM_CONTROL2_PROTOCOL_GUID EFI_MM_CONTROL_PROTOCOL_GUID
typedef struct _EFI_SMM_CONTROL2_PROTOCOL EFI_SMM_CONTROL2_PROTOCOL;
typedef UINTN EFI_SMM_PERIOD;
typedef EFI_MM_CONTROL_PROTOCOL EFI_SMM_CONTROL2_PROTOCOL;
typedef EFI_MM_PERIOD EFI_SMM_PERIOD;
/**
Invokes SMI activation from either the preboot or runtime environment.
This function generates an SMI.
@param[in] This The EFI_SMM_CONTROL2_PROTOCOL instance.
@param[in,out] CommandPort The value written to the command port.
@param[in,out] DataPort The value written to the data port.
@param[in] Periodic Optional mechanism to engender a periodic stream.
@param[in] ActivationInterval Optional parameter to repeat at this period one
time or, if the Periodic Boolean is set, periodically.
@retval EFI_SUCCESS The SMI/PMI has been engendered.
@retval EFI_DEVICE_ERROR The timing is unsupported.
@retval EFI_INVALID_PARAMETER The activation period is unsupported.
@retval EFI_INVALID_PARAMETER The last periodic activation has not been cleared.
@retval EFI_NOT_STARTED The SMM base service has not been initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ACTIVATE2)(
IN CONST EFI_SMM_CONTROL2_PROTOCOL *This,
IN OUT UINT8 *CommandPort OPTIONAL,
IN OUT UINT8 *DataPort OPTIONAL,
IN BOOLEAN Periodic OPTIONAL,
IN UINTN ActivationInterval OPTIONAL
);
/**
Clears any system state that was created in response to the Trigger() call.
This function acknowledges and causes the deassertion of the SMI activation source.
@param[in] This The EFI_SMM_CONTROL2_PROTOCOL instance.
@param[in] Periodic Optional parameter to repeat at this period one time
@retval EFI_SUCCESS The SMI/PMI has been engendered.
@retval EFI_DEVICE_ERROR The source could not be cleared.
@retval EFI_INVALID_PARAMETER The service did not support the Periodic input argument.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_DEACTIVATE2)(
IN CONST EFI_SMM_CONTROL2_PROTOCOL *This,
IN BOOLEAN Periodic OPTIONAL
);
///
/// The EFI_SMM_CONTROL2_PROTOCOL is produced by a runtime driver. It provides an
/// abstraction of the platform hardware that generates an SMI. There are often I/O ports that, when
/// accessed, will generate the SMI. Also, the hardware optionally supports the periodic generation of
/// these signals.
///
struct _EFI_SMM_CONTROL2_PROTOCOL {
EFI_SMM_ACTIVATE2 Trigger;
EFI_SMM_DEACTIVATE2 Clear;
///
/// Minimum interval at which the platform can set the period. A maximum is not
/// specified in that the SMM infrastructure code can emulate a maximum interval that is
/// greater than the hardware capabilities by using software emulation in the SMM
/// infrastructure code.
///
EFI_SMM_PERIOD MinimumTriggerPeriod;
};
typedef EFI_MM_ACTIVATE EFI_SMM_ACTIVATE2;
typedef EFI_MM_DEACTIVATE EFI_SMM_DEACTIVATE2;
extern EFI_GUID gEfiSmmControl2ProtocolGuid;
#endif

305
MdePkg/Include/Protocol/SmmCpu.h
View File

@ -6,7 +6,7 @@
but not in the same format. These so-called pseudo-registers provide this information in a standard
format.
Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -20,227 +20,116 @@
#ifndef _SMM_CPU_H_
#define _SMM_CPU_H_
#define EFI_SMM_CPU_PROTOCOL_GUID \
{ \
0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 } \
}
#include <Protocol/MmCpu.h>
///
/// Save State register index
///
typedef enum {
///
/// x86/X64 standard registers
///
EFI_SMM_SAVE_STATE_REGISTER_GDTBASE = 4,
EFI_SMM_SAVE_STATE_REGISTER_IDTBASE = 5,
EFI_SMM_SAVE_STATE_REGISTER_LDTBASE = 6,
EFI_SMM_SAVE_STATE_REGISTER_GDTLIMIT = 7,
EFI_SMM_SAVE_STATE_REGISTER_IDTLIMIT = 8,
EFI_SMM_SAVE_STATE_REGISTER_LDTLIMIT = 9,
EFI_SMM_SAVE_STATE_REGISTER_LDTINFO = 10,
EFI_SMM_SAVE_STATE_REGISTER_ES = 20,
EFI_SMM_SAVE_STATE_REGISTER_CS = 21,
EFI_SMM_SAVE_STATE_REGISTER_SS = 22,
EFI_SMM_SAVE_STATE_REGISTER_DS = 23,
EFI_SMM_SAVE_STATE_REGISTER_FS = 24,
EFI_SMM_SAVE_STATE_REGISTER_GS = 25,
EFI_SMM_SAVE_STATE_REGISTER_LDTR_SEL = 26,
EFI_SMM_SAVE_STATE_REGISTER_TR_SEL = 27,
EFI_SMM_SAVE_STATE_REGISTER_DR7 = 28,
EFI_SMM_SAVE_STATE_REGISTER_DR6 = 29,
EFI_SMM_SAVE_STATE_REGISTER_R8 = 30,
EFI_SMM_SAVE_STATE_REGISTER_R9 = 31,
EFI_SMM_SAVE_STATE_REGISTER_R10 = 32,
EFI_SMM_SAVE_STATE_REGISTER_R11 = 33,
EFI_SMM_SAVE_STATE_REGISTER_R12 = 34,
EFI_SMM_SAVE_STATE_REGISTER_R13 = 35,
EFI_SMM_SAVE_STATE_REGISTER_R14 = 36,
EFI_SMM_SAVE_STATE_REGISTER_R15 = 37,
EFI_SMM_SAVE_STATE_REGISTER_RAX = 38,
EFI_SMM_SAVE_STATE_REGISTER_RBX = 39,
EFI_SMM_SAVE_STATE_REGISTER_RCX = 40,
EFI_SMM_SAVE_STATE_REGISTER_RDX = 41,
EFI_SMM_SAVE_STATE_REGISTER_RSP = 42,
EFI_SMM_SAVE_STATE_REGISTER_RBP = 43,
EFI_SMM_SAVE_STATE_REGISTER_RSI = 44,
EFI_SMM_SAVE_STATE_REGISTER_RDI = 45,
EFI_SMM_SAVE_STATE_REGISTER_RIP = 46,
EFI_SMM_SAVE_STATE_REGISTER_RFLAGS = 51,
EFI_SMM_SAVE_STATE_REGISTER_CR0 = 52,
EFI_SMM_SAVE_STATE_REGISTER_CR3 = 53,
EFI_SMM_SAVE_STATE_REGISTER_CR4 = 54,
EFI_SMM_SAVE_STATE_REGISTER_FCW = 256,
EFI_SMM_SAVE_STATE_REGISTER_FSW = 257,
EFI_SMM_SAVE_STATE_REGISTER_FTW = 258,
EFI_SMM_SAVE_STATE_REGISTER_OPCODE = 259,
EFI_SMM_SAVE_STATE_REGISTER_FP_EIP = 260,
EFI_SMM_SAVE_STATE_REGISTER_FP_CS = 261,
EFI_SMM_SAVE_STATE_REGISTER_DATAOFFSET = 262,
EFI_SMM_SAVE_STATE_REGISTER_FP_DS = 263,
EFI_SMM_SAVE_STATE_REGISTER_MM0 = 264,
EFI_SMM_SAVE_STATE_REGISTER_MM1 = 265,
EFI_SMM_SAVE_STATE_REGISTER_MM2 = 266,
EFI_SMM_SAVE_STATE_REGISTER_MM3 = 267,
EFI_SMM_SAVE_STATE_REGISTER_MM4 = 268,
EFI_SMM_SAVE_STATE_REGISTER_MM5 = 269,
EFI_SMM_SAVE_STATE_REGISTER_MM6 = 270,
EFI_SMM_SAVE_STATE_REGISTER_MM7 = 271,
EFI_SMM_SAVE_STATE_REGISTER_XMM0 = 272,
EFI_SMM_SAVE_STATE_REGISTER_XMM1 = 273,
EFI_SMM_SAVE_STATE_REGISTER_XMM2 = 274,
EFI_SMM_SAVE_STATE_REGISTER_XMM3 = 275,
EFI_SMM_SAVE_STATE_REGISTER_XMM4 = 276,
EFI_SMM_SAVE_STATE_REGISTER_XMM5 = 277,
EFI_SMM_SAVE_STATE_REGISTER_XMM6 = 278,
EFI_SMM_SAVE_STATE_REGISTER_XMM7 = 279,
EFI_SMM_SAVE_STATE_REGISTER_XMM8 = 280,
EFI_SMM_SAVE_STATE_REGISTER_XMM9 = 281,
EFI_SMM_SAVE_STATE_REGISTER_XMM10 = 282,
EFI_SMM_SAVE_STATE_REGISTER_XMM11 = 283,
EFI_SMM_SAVE_STATE_REGISTER_XMM12 = 284,
EFI_SMM_SAVE_STATE_REGISTER_XMM13 = 285,
EFI_SMM_SAVE_STATE_REGISTER_XMM14 = 286,
EFI_SMM_SAVE_STATE_REGISTER_XMM15 = 287,
///
/// Pseudo-Registers
///
EFI_SMM_SAVE_STATE_REGISTER_IO = 512,
EFI_SMM_SAVE_STATE_REGISTER_LMA = 513,
EFI_SMM_SAVE_STATE_REGISTER_PROCESSOR_ID = 514
} EFI_SMM_SAVE_STATE_REGISTER;
#define EFI_SMM_CPU_PROTOCOL_GUID EFI_MM_CPU_PROTOCOL_GUID
#define EFI_SMM_SAVE_STATE_REGISTER_GDTBASE EFI_MM_SAVE_STATE_REGISTER_GDTBASE
#define EFI_SMM_SAVE_STATE_REGISTER_IDTBASE EFI_MM_SAVE_STATE_REGISTER_IDTBASE
#define EFI_SMM_SAVE_STATE_REGISTER_LDTBASE EFI_MM_SAVE_STATE_REGISTER_LDTBASE
#define EFI_SMM_SAVE_STATE_REGISTER_GDTLIMIT EFI_MM_SAVE_STATE_REGISTER_GDTLIMIT
#define EFI_SMM_SAVE_STATE_REGISTER_IDTLIMIT EFI_MM_SAVE_STATE_REGISTER_IDTLIMIT
#define EFI_SMM_SAVE_STATE_REGISTER_LDTLIMIT EFI_MM_SAVE_STATE_REGISTER_LDTLIMIT
#define EFI_SMM_SAVE_STATE_REGISTER_LDTINFO EFI_MM_SAVE_STATE_REGISTER_LDTINFO
#define EFI_SMM_SAVE_STATE_REGISTER_ES EFI_MM_SAVE_STATE_REGISTER_ES
#define EFI_SMM_SAVE_STATE_REGISTER_CS EFI_MM_SAVE_STATE_REGISTER_CS
#define EFI_SMM_SAVE_STATE_REGISTER_SS EFI_MM_SAVE_STATE_REGISTER_SS
#define EFI_SMM_SAVE_STATE_REGISTER_DS EFI_MM_SAVE_STATE_REGISTER_DS
#define EFI_SMM_SAVE_STATE_REGISTER_FS EFI_MM_SAVE_STATE_REGISTER_FS
#define EFI_SMM_SAVE_STATE_REGISTER_GS EFI_MM_SAVE_STATE_REGISTER_GS
#define EFI_SMM_SAVE_STATE_REGISTER_LDTR_SEL EFI_MM_SAVE_STATE_REGISTER_LDTR_SEL
#define EFI_SMM_SAVE_STATE_REGISTER_TR_SEL EFI_MM_SAVE_STATE_REGISTER_TR_SEL
#define EFI_SMM_SAVE_STATE_REGISTER_DR7 EFI_MM_SAVE_STATE_REGISTER_DR7
#define EFI_SMM_SAVE_STATE_REGISTER_DR6 EFI_MM_SAVE_STATE_REGISTER_DR6
#define EFI_SMM_SAVE_STATE_REGISTER_R8 EFI_MM_SAVE_STATE_REGISTER_R8
#define EFI_SMM_SAVE_STATE_REGISTER_R9 EFI_MM_SAVE_STATE_REGISTER_R9
#define EFI_SMM_SAVE_STATE_REGISTER_R10 EFI_MM_SAVE_STATE_REGISTER_R10
#define EFI_SMM_SAVE_STATE_REGISTER_R11 EFI_MM_SAVE_STATE_REGISTER_R11
#define EFI_SMM_SAVE_STATE_REGISTER_R12 EFI_MM_SAVE_STATE_REGISTER_R12
#define EFI_SMM_SAVE_STATE_REGISTER_R13 EFI_MM_SAVE_STATE_REGISTER_R13
#define EFI_SMM_SAVE_STATE_REGISTER_R14 EFI_MM_SAVE_STATE_REGISTER_R14
#define EFI_SMM_SAVE_STATE_REGISTER_R15 EFI_MM_SAVE_STATE_REGISTER_R15
#define EFI_SMM_SAVE_STATE_REGISTER_RAX EFI_MM_SAVE_STATE_REGISTER_RAX
#define EFI_SMM_SAVE_STATE_REGISTER_RBX EFI_MM_SAVE_STATE_REGISTER_RBX
#define EFI_SMM_SAVE_STATE_REGISTER_RCX EFI_MM_SAVE_STATE_REGISTER_RCX
#define EFI_SMM_SAVE_STATE_REGISTER_RDX EFI_MM_SAVE_STATE_REGISTER_RDX
#define EFI_SMM_SAVE_STATE_REGISTER_RSP EFI_MM_SAVE_STATE_REGISTER_RSP
#define EFI_SMM_SAVE_STATE_REGISTER_RBP EFI_MM_SAVE_STATE_REGISTER_RBP
#define EFI_SMM_SAVE_STATE_REGISTER_RSI EFI_MM_SAVE_STATE_REGISTER_RSI
#define EFI_SMM_SAVE_STATE_REGISTER_RDI EFI_MM_SAVE_STATE_REGISTER_RDI
#define EFI_SMM_SAVE_STATE_REGISTER_RIP EFI_MM_SAVE_STATE_REGISTER_RIP
#define EFI_SMM_SAVE_STATE_REGISTER_RFLAGS EFI_MM_SAVE_STATE_REGISTER_RFLAGS
#define EFI_SMM_SAVE_STATE_REGISTER_CR0 EFI_MM_SAVE_STATE_REGISTER_CR0
#define EFI_SMM_SAVE_STATE_REGISTER_CR3 EFI_MM_SAVE_STATE_REGISTER_CR3
#define EFI_SMM_SAVE_STATE_REGISTER_CR4 EFI_MM_SAVE_STATE_REGISTER_CR4
#define EFI_SMM_SAVE_STATE_REGISTER_FCW EFI_MM_SAVE_STATE_REGISTER_FCW
#define EFI_SMM_SAVE_STATE_REGISTER_FSW EFI_MM_SAVE_STATE_REGISTER_FSW
#define EFI_SMM_SAVE_STATE_REGISTER_FTW EFI_MM_SAVE_STATE_REGISTER_FTW
#define EFI_SMM_SAVE_STATE_REGISTER_OPCODE EFI_MM_SAVE_STATE_REGISTER_OPCODE
#define EFI_SMM_SAVE_STATE_REGISTER_FP_EIP EFI_MM_SAVE_STATE_REGISTER_FP_EIP
#define EFI_SMM_SAVE_STATE_REGISTER_FP_CS EFI_MM_SAVE_STATE_REGISTER_FP_CS
#define EFI_SMM_SAVE_STATE_REGISTER_DATAOFFSET EFI_MM_SAVE_STATE_REGISTER_DATAOFFSET
#define EFI_SMM_SAVE_STATE_REGISTER_FP_DS EFI_MM_SAVE_STATE_REGISTER_FP_DS
#define EFI_SMM_SAVE_STATE_REGISTER_MM0 EFI_MM_SAVE_STATE_REGISTER_MM0
#define EFI_SMM_SAVE_STATE_REGISTER_MM1 EFI_MM_SAVE_STATE_REGISTER_MM1
#define EFI_SMM_SAVE_STATE_REGISTER_MM2 EFI_MM_SAVE_STATE_REGISTER_MM2
#define EFI_SMM_SAVE_STATE_REGISTER_MM3 EFI_MM_SAVE_STATE_REGISTER_MM3
#define EFI_SMM_SAVE_STATE_REGISTER_MM4 EFI_MM_SAVE_STATE_REGISTER_MM4
#define EFI_SMM_SAVE_STATE_REGISTER_MM5 EFI_MM_SAVE_STATE_REGISTER_MM5
#define EFI_SMM_SAVE_STATE_REGISTER_MM6 EFI_MM_SAVE_STATE_REGISTER_MM6
#define EFI_SMM_SAVE_STATE_REGISTER_MM7 EFI_MM_SAVE_STATE_REGISTER_MM7
#define EFI_SMM_SAVE_STATE_REGISTER_XMM0 EFI_MM_SAVE_STATE_REGISTER_XMM0
#define EFI_SMM_SAVE_STATE_REGISTER_XMM1 EFI_MM_SAVE_STATE_REGISTER_XMM1
#define EFI_SMM_SAVE_STATE_REGISTER_XMM2 EFI_MM_SAVE_STATE_REGISTER_XMM2
#define EFI_SMM_SAVE_STATE_REGISTER_XMM3 EFI_MM_SAVE_STATE_REGISTER_XMM3
#define EFI_SMM_SAVE_STATE_REGISTER_XMM4 EFI_MM_SAVE_STATE_REGISTER_XMM4
#define EFI_SMM_SAVE_STATE_REGISTER_XMM5 EFI_MM_SAVE_STATE_REGISTER_XMM5
#define EFI_SMM_SAVE_STATE_REGISTER_XMM6 EFI_MM_SAVE_STATE_REGISTER_XMM6
#define EFI_SMM_SAVE_STATE_REGISTER_XMM7 EFI_MM_SAVE_STATE_REGISTER_XMM7
#define EFI_SMM_SAVE_STATE_REGISTER_XMM8 EFI_MM_SAVE_STATE_REGISTER_XMM8
#define EFI_SMM_SAVE_STATE_REGISTER_XMM9 EFI_MM_SAVE_STATE_REGISTER_XMM9
#define EFI_SMM_SAVE_STATE_REGISTER_XMM10 EFI_MM_SAVE_STATE_REGISTER_XMM10
#define EFI_SMM_SAVE_STATE_REGISTER_XMM11 EFI_MM_SAVE_STATE_REGISTER_XMM11
#define EFI_SMM_SAVE_STATE_REGISTER_XMM12 EFI_MM_SAVE_STATE_REGISTER_XMM12
#define EFI_SMM_SAVE_STATE_REGISTER_XMM13 EFI_MM_SAVE_STATE_REGISTER_XMM13
#define EFI_SMM_SAVE_STATE_REGISTER_XMM14 EFI_MM_SAVE_STATE_REGISTER_XMM14
#define EFI_SMM_SAVE_STATE_REGISTER_XMM15 EFI_MM_SAVE_STATE_REGISTER_XMM15
#define EFI_SMM_SAVE_STATE_REGISTER_IO EFI_MM_SAVE_STATE_REGISTER_IO
#define EFI_SMM_SAVE_STATE_REGISTER_LMA EFI_MM_SAVE_STATE_REGISTER_LMA
#define EFI_SMM_SAVE_STATE_REGISTER_PROCESSOR_ID EFI_MM_SAVE_STATE_REGISTER_PROCESSOR_ID
typedef EFI_MM_SAVE_STATE_REGISTER EFI_SMM_SAVE_STATE_REGISTER;
#define EFI_SMM_SAVE_STATE_REGISTER_LMA_32BIT EFI_MM_SAVE_STATE_REGISTER_LMA_32BIT
#define EFI_SMM_SAVE_STATE_REGISTER_LMA_64BIT EFI_MM_SAVE_STATE_REGISTER_LMA_64BIT
///
/// The EFI_SMM_SAVE_STATE_REGISTER_LMA pseudo-register values
/// If the processor acts in 32-bit mode at the time the SMI occurred, the pseudo register value
/// EFI_SMM_SAVE_STATE_REGISTER_LMA_32BIT is returned in Buffer. Otherwise,
/// EFI_SMM_SAVE_STATE_REGISTER_LMA_64BIT is returned in Buffer.
///
#define EFI_SMM_SAVE_STATE_REGISTER_LMA_32BIT 32
#define EFI_SMM_SAVE_STATE_REGISTER_LMA_64BIT 64
///
/// Size width of I/O instruction
///
typedef enum {
EFI_SMM_SAVE_STATE_IO_WIDTH_UINT8 = 0,
EFI_SMM_SAVE_STATE_IO_WIDTH_UINT16 = 1,
EFI_SMM_SAVE_STATE_IO_WIDTH_UINT32 = 2,
EFI_SMM_SAVE_STATE_IO_WIDTH_UINT64 = 3
} EFI_SMM_SAVE_STATE_IO_WIDTH;
#define EFI_SMM_SAVE_STATE_IO_WIDTH_UINT8 EFI_MM_SAVE_STATE_IO_WIDTH_UINT8
#define EFI_SMM_SAVE_STATE_IO_WIDTH_UINT16 EFI_MM_SAVE_STATE_IO_WIDTH_UINT16
#define EFI_SMM_SAVE_STATE_IO_WIDTH_UINT32 EFI_MM_SAVE_STATE_IO_WIDTH_UINT32
#define EFI_SMM_SAVE_STATE_IO_WIDTH_UINT64 EFI_MM_SAVE_STATE_IO_WIDTH_UINT64
typedef EFI_MM_SAVE_STATE_IO_WIDTH EFI_SMM_SAVE_STATE_IO_WIDTH;
///
/// Types of I/O instruction
///
typedef enum {
EFI_SMM_SAVE_STATE_IO_TYPE_INPUT = 1,
EFI_SMM_SAVE_STATE_IO_TYPE_OUTPUT = 2,
EFI_SMM_SAVE_STATE_IO_TYPE_STRING = 4,
EFI_SMM_SAVE_STATE_IO_TYPE_REP_PREFIX = 8
} EFI_SMM_SAVE_STATE_IO_TYPE;
#define EFI_SMM_SAVE_STATE_IO_TYPE_INPUT EFI_MM_SAVE_STATE_IO_TYPE_INPUT
#define EFI_SMM_SAVE_STATE_IO_TYPE_OUTPUT EFI_MM_SAVE_STATE_IO_TYPE_OUTPUT
#define EFI_SMM_SAVE_STATE_IO_TYPE_STRING EFI_MM_SAVE_STATE_IO_TYPE_STRING
#define EFI_SMM_SAVE_STATE_IO_TYPE_REP_PREFIX EFI_MM_SAVE_STATE_IO_TYPE_REP_PREFIX
typedef EFI_MM_SAVE_STATE_IO_TYPE EFI_SMM_SAVE_STATE_IO_TYPE;
///
/// Structure of the data which is returned when ReadSaveState() is called with
/// EFI_SMM_SAVE_STATE_REGISTER_IO. If there was no I/O then ReadSaveState() will
/// return EFI_NOT_FOUND.
///
/// This structure describes the I/O operation which was in process when the SMI was generated.
///
typedef struct _EFI_SMM_SAVE_STATE_IO_INFO {
///
/// For input instruction (IN, INS), this is data read before the SMI occurred. For output
/// instructions (OUT, OUTS) this is data that was written before the SMI occurred. The
/// width of the data is specified by IoWidth.
///
UINT64 IoData;
///
/// The I/O port that was being accessed when the SMI was triggered.
///
UINT16 IoPort;
///
/// Defines the size width (UINT8, UINT16, UINT32, UINT64) for IoData.
///
EFI_SMM_SAVE_STATE_IO_WIDTH IoWidth;
///
/// Defines type of I/O instruction.
///
EFI_SMM_SAVE_STATE_IO_TYPE IoType;
} EFI_SMM_SAVE_STATE_IO_INFO;
typedef struct _EFI_SMM_CPU_PROTOCOL EFI_SMM_CPU_PROTOCOL;
typedef EFI_MM_SAVE_STATE_IO_INFO EFI_SMM_SAVE_STATE_IO_INFO;
/**
Read data from the CPU save state.
typedef EFI_MM_CPU_PROTOCOL EFI_SMM_CPU_PROTOCOL;
This function is used to read the specified number of bytes of the specified register from the CPU
save state of the specified CPU and place the value into the buffer. If the CPU does not support the
specified register Register, then EFI_NOT_FOUND should be returned. If the CPU does not
support the specified register width Width, then EFI_INVALID_PARAMETER is returned.
@param[in] This The EFI_SMM_CPU_PROTOCOL instance.
@param[in] Width The number of bytes to read from the CPU save state.
@param[in] Register Specifies the CPU register to read form the save state.
@param[in] CpuIndex Specifies the zero-based index of the CPU save state.
@param[out] Buffer Upon return, this holds the CPU register value read from the save state.
@retval EFI_SUCCESS The register was read from Save State.
@retval EFI_NOT_FOUND The register is not defined for the Save State of Processor.
@retval EFI_INVALID_PARAMETER Input parameters are not valid, for example, Processor No or register width
is not correct.This or Buffer is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_READ_SAVE_STATE)(
IN CONST EFI_SMM_CPU_PROTOCOL *This,
IN UINTN Width,
IN EFI_SMM_SAVE_STATE_REGISTER Register,
IN UINTN CpuIndex,
OUT VOID *Buffer
);
/**
Write data to the CPU save state.
This function is used to write the specified number of bytes of the specified register to the CPU save
state of the specified CPU and place the value into the buffer. If the CPU does not support the
specified register Register, then EFI_UNSUPPORTED should be returned. If the CPU does not
support the specified register width Width, then EFI_INVALID_PARAMETER is returned.
@param[in] This The EFI_SMM_CPU_PROTOCOL instance.
@param[in] Width The number of bytes to write to the CPU save state.
@param[in] Register Specifies the CPU register to write to the save state.
@param[in] CpuIndex Specifies the zero-based index of the CPU save state.
@param[in] Buffer Upon entry, this holds the new CPU register value.
@retval EFI_SUCCESS The register was written to Save State.
@retval EFI_NOT_FOUND The register is not defined for the Save State of Processor.
@retval EFI_INVALID_PARAMETER Input parameters are not valid. For example:
ProcessorIndex or Width is not correct.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_WRITE_SAVE_STATE)(
IN CONST EFI_SMM_CPU_PROTOCOL *This,
IN UINTN Width,
IN EFI_SMM_SAVE_STATE_REGISTER Register,
IN UINTN CpuIndex,
IN CONST VOID *Buffer
);
///
/// EFI SMM CPU Protocol provides access to CPU-related information while in SMM.
///
/// This protocol allows SMM drivers to access architecture-standard registers from any of the CPU
/// save state areas. In some cases, difference processors provide the same information in the save state,
/// but not in the same format. These so-called pseudo-registers provide this information in a standard
/// format.
///
struct _EFI_SMM_CPU_PROTOCOL {
EFI_SMM_READ_SAVE_STATE ReadSaveState;
EFI_SMM_WRITE_SAVE_STATE WriteSaveState;
};
typedef EFI_MM_READ_SAVE_STATE EFI_SMM_READ_SAVE_STATE;
typedef EFI_MM_WRITE_SAVE_STATE EFI_SMM_WRITE_SAVE_STATE;
extern EFI_GUID gEfiSmmCpuProtocolGuid;
#endif

79
MdePkg/Include/Protocol/SmmCpuIo2.h
View File

@ -3,7 +3,7 @@
This protocol provides CPU I/O and memory access within SMM.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -17,79 +17,24 @@
#ifndef _SMM_CPU_IO2_H_
#define _SMM_CPU_IO2_H_
#define EFI_SMM_CPU_IO2_PROTOCOL_GUID \
{ \
0x3242A9D8, 0xCE70, 0x4AA0, { 0x95, 0x5D, 0x5E, 0x7B, 0x14, 0x0D, 0xE4, 0xD2 } \
}
#include <Protocol/MmCpuIo.h>
typedef struct _EFI_SMM_CPU_IO2_PROTOCOL EFI_SMM_CPU_IO2_PROTOCOL;
#define EFI_SMM_CPU_IO2_PROTOCOL_GUID EFI_MM_CPU_IO_PROTOCOL_GUID
typedef EFI_MM_CPU_IO_PROTOCOL EFI_SMM_CPU_IO2_PROTOCOL;
///
/// Width of the SMM CPU I/O operations
///
typedef enum {
SMM_IO_UINT8 = 0,
SMM_IO_UINT16 = 1,
SMM_IO_UINT32 = 2,
SMM_IO_UINT64 = 3
} EFI_SMM_IO_WIDTH;
#define SMM_IO_UINT8 MM_IO_UINT8
#define SMM_IO_UINT16 MM_IO_UINT16
#define SMM_IO_UINT32 MM_IO_UINT32
#define SMM_IO_UINT64 MM_IO_UINT64
/**
Provides the basic memory and I/O interfaces used toabstract accesses to devices.
typedef EFI_MM_IO_WIDTH EFI_SMM_IO_WIDTH;
typedef EFI_MM_CPU_IO EFI_SMM_CPU_IO2;
The I/O operations are carried out exactly as requested. The caller is
responsible for any alignment and I/O width issues that the bus, device,
platform, or type of I/O might require.
@param[in] This The EFI_SMM_CPU_IO2_PROTOCOL instance.
@param[in] Width Signifies the width of the I/O operations.
@param[in] Address The base address of the I/O operations. The caller is
responsible for aligning the Address if required.
@param[in] Count The number of I/O operations to perform.
@param[in,out] Buffer For read operations, the destination buffer to store
the results. For write operations, the source buffer
from which to write data.
@retval EFI_SUCCESS The data was read from or written to the device.
@retval EFI_UNSUPPORTED The Address is not valid for this system.
@retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid.
@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack
of resources.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CPU_IO2)(
IN CONST EFI_SMM_CPU_IO2_PROTOCOL *This,
IN EFI_SMM_IO_WIDTH Width,
IN UINT64 Address,
IN UINTN Count,
IN OUT VOID *Buffer
);
typedef struct {
///
/// This service provides the various modalities of memory and I/O read.
///
EFI_SMM_CPU_IO2 Read;
///
/// This service provides the various modalities of memory and I/O write.
///
EFI_SMM_CPU_IO2 Write;
} EFI_SMM_IO_ACCESS2;
///
/// SMM CPU I/O Protocol provides CPU I/O and memory access within SMM.
///
struct _EFI_SMM_CPU_IO2_PROTOCOL {
///
/// Allows reads and writes to memory-mapped I/O space.
///
EFI_SMM_IO_ACCESS2 Mem;
///
/// Allows reads and writes to I/O space.
///
EFI_SMM_IO_ACCESS2 Io;
};
typedef EFI_MM_IO_ACCESS EFI_SMM_IO_ACCESS2;
extern EFI_GUID gEfiSmmCpuIo2ProtocolGuid;

9
MdePkg/Include/Protocol/SmmEndOfDxe.h
View File

@ -9,7 +9,7 @@
This protocol prorogates End of DXE notification into SMM environment.
This protocol is installed prior to installation of the SMM Ready to Lock Protocol.
Copyright (c) 2012 - 2016, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2012 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -23,10 +23,9 @@
#ifndef _SMM_END_OF_DXE_H_
#define _SMM_END_OF_DXE_H_
#define EFI_SMM_END_OF_DXE_PROTOCOL_GUID \
{ \
0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d } \
}
#include <Protocol/MmEndOfDxe.h>
#define EFI_SMM_END_OF_DXE_PROTOCOL_GUID EFI_MM_END_OF_DXE_PROTOCOL_GUID
extern EFI_GUID gEfiSmmEndOfDxeProtocolGuid;

90
MdePkg/Include/Protocol/SmmGpiDispatch2.h
View File

@ -9,7 +9,7 @@
given event types. Several inputs can be enabled. This purpose of this interface is to generate an
SMI in response to any of these inputs having a true value provided.
Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -26,98 +26,22 @@
#ifndef _SMM_GPI_DISPATCH2_H_
#define _SMM_GPI_DISPATCH2_H_
#include <Protocol/MmGpiDispatch.h>
#include <Pi/PiSmmCis.h>
#define EFI_SMM_GPI_DISPATCH2_PROTOCOL_GUID \
{ \
0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 } \
}
#define EFI_SMM_GPI_DISPATCH2_PROTOCOL_GUID EFI_MM_GPI_DISPATCH_PROTOCOL_GUID
///
/// The dispatch function's context.
///
typedef struct {
///
/// A number from one of 2^64 possible GPIs that can generate an SMI. A
/// 0 corresponds to logical GPI[0]; 1 corresponds to logical GPI[1]; and
/// GpiNum of N corresponds to GPI[N], where N can span from 0 to 2^64-1.
///
UINT64 GpiNum;
} EFI_SMM_GPI_REGISTER_CONTEXT;
typedef EFI_MM_GPI_REGISTER_CONTEXT EFI_SMM_GPI_REGISTER_CONTEXT;
typedef struct _EFI_SMM_GPI_DISPATCH2_PROTOCOL EFI_SMM_GPI_DISPATCH2_PROTOCOL;
typedef EFI_MM_GPI_REGISTER EFI_SMM_GPI_REGISTER2;
/**
Registers a child SMI source dispatch function with a parent SMM driver.
typedef EFI_MM_GPI_UNREGISTER EFI_SMM_GPI_UNREGISTER2;
This service registers a function (DispatchFunction) which will be called when an SMI is
generated because of one or more of the GPIs specified by RegisterContext. On return,
DispatchHandle contains a unique handle which may be used later to unregister the function
using UnRegister().
The DispatchFunction will be called with Context set to the same value as was passed into
this function in RegisterContext and with CommBuffer pointing to another instance of
EFI_SMM_GPI_REGISTER_CONTEXT describing the GPIs which actually caused the SMI and
CommBufferSize pointing to the size of the structure.
typedef EFI_MM_GPI_DISPATCH_PROTOCOL EFI_SMM_GPI_DISPATCH2_PROTOCOL;
@param[in] This Pointer to the EFI_SMM_GPI_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when the specified GPI causes an SMI.
@param[in] RegisterContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function the GPI(s) for which the dispatch function
should be invoked.
@param[out] DispatchHandle Handle generated by the dispatcher to track the
function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. The GPI input value
is not within valid range.
@retval EFI_OUT_OF_RESOURCES There is not enough memory (system or SMM) to manage this child.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GPI_REGISTER2)(
IN CONST EFI_SMM_GPI_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN CONST EFI_SMM_GPI_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a General Purpose Input (GPI) service.
This service removes the handler associated with DispatchHandle so that it will no longer be
called when the GPI triggers an SMI.
@param[in] This Pointer to the EFI_SMM_GPI_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS Handle of the service to remove.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GPI_UNREGISTER2)(
IN CONST EFI_SMM_GPI_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// Interface structure for the SMM GPI SMI Dispatch Protocol
///
/// The SMM GPI SMI Dispatch Protocol provides the parent dispatch service
/// for the General Purpose Input (GPI) SMI source generator.
///
struct _EFI_SMM_GPI_DISPATCH2_PROTOCOL {
EFI_SMM_GPI_REGISTER2 Register;
EFI_SMM_GPI_UNREGISTER2 UnRegister;
///
/// Denotes the maximum value of inputs that can have handlers attached.
///
UINTN NumSupportedGpis;
};
extern EFI_GUID gEfiSmmGpiDispatch2ProtocolGuid;

101
MdePkg/Include/Protocol/SmmIoTrapDispatch2.h
View File

@ -4,7 +4,7 @@
This protocol provides a parent dispatch service for IO trap SMI sources.
Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -21,114 +21,31 @@
#ifndef _SMM_IO_TRAP_DISPATCH2_H_
#define _SMM_IO_TRAP_DISPATCH2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmIoTrapDispatch.h>
#define EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL_GUID \
{ \
0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 } \
}
#define EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL_GUID EFI_MM_IO_TRAP_DISPATCH_PROTOCOL_GUID
///
/// IO Trap valid types
///
typedef enum {
WriteTrap,
ReadTrap,
ReadWriteTrap,
IoTrapTypeMaximum
} EFI_SMM_IO_TRAP_DISPATCH_TYPE;
typedef EFI_MM_IO_TRAP_DISPATCH_TYPE EFI_SMM_IO_TRAP_DISPATCH_TYPE;
///
/// IO Trap context structure containing information about the
/// IO trap event that should invoke the handler
///
typedef struct {
UINT16 Address;
UINT16 Length;
EFI_SMM_IO_TRAP_DISPATCH_TYPE Type;
} EFI_SMM_IO_TRAP_REGISTER_CONTEXT;
typedef EFI_MM_IO_TRAP_REGISTER_CONTEXT EFI_SMM_IO_TRAP_REGISTER_CONTEXT;
///
/// IO Trap context structure containing information about the IO trap that occurred
///
typedef struct {
UINT32 WriteData;
} EFI_SMM_IO_TRAP_CONTEXT;
typedef EFI_MM_IO_TRAP_CONTEXT EFI_SMM_IO_TRAP_CONTEXT;
typedef struct _EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL;
typedef EFI_MM_IO_TRAP_DISPATCH_PROTOCOL EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL;
/**
Register an IO trap SMI child handler for a specified SMI.
typedef EFI_MM_IO_TRAP_DISPATCH_REGISTER EFI_SMM_IO_TRAP_DISPATCH2_REGISTER;
This service registers a function (DispatchFunction) which will be called when an SMI is
generated because of an access to an I/O port specified by RegisterContext. On return,
DispatchHandle contains a unique handle which may be used later to unregister the function
using UnRegister(). If the base of the I/O range specified is zero, then an I/O range with the
specified length and characteristics will be allocated and the Address field in RegisterContext
updated. If no range could be allocated, then EFI_OUT_OF_RESOURCES will be returned.
The service will not perform GCD allocation if the base address is non-zero or
EFI_SMM_READY_TO_LOCK has been installed. In this case, the caller is responsible for the
existence and allocation of the specific IO range.
An error may be returned if some or all of the requested resources conflict with an existing IO trap
child handler.
It is not required that implementations will allow multiple children for a single IO trap SMI source.
Some implementations may support multiple children.
The DispatchFunction will be called with Context updated to contain information
concerning the I/O action that actually happened and is passed in RegisterContext, with
CommBuffer pointing to the data actually written and CommBufferSize pointing to the size of
the data in CommBuffer.
@param[in] This Pointer to the EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when I/O trap location is accessed.
@param[in] RegisterContext Pointer to the dispatch function's context. The caller fills this
context in before calling the register function to indicate to the register
function the IO trap SMI source for which the dispatch function should be invoked.
@param[out] DispatchHandle Handle of the dispatch function, for when interfacing with the parent SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully registered.
@retval EFI_DEVICE_ERROR The driver was unable to complete due to hardware error.
@retval EFI_OUT_OF_RESOURCES Insufficient resources are available to fulfill the IO trap range request.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. The input value is not within a valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_IO_TRAP_DISPATCH2_REGISTER)(
IN CONST EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN OUT EFI_SMM_IO_TRAP_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver.
This service removes a previously installed child dispatch handler. This does not guarantee that the
system resources will be freed from the GCD.
@param[in] This Pointer to the EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the child service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully unregistered.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_IO_TRAP_DISPATCH2_UNREGISTER)(
IN CONST EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// Interface structure for the SMM IO Trap Dispatch2 Protocol.
///
/// This protocol provides a parent dispatch service for IO trap SMI sources.
///
struct _EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL {
EFI_SMM_IO_TRAP_DISPATCH2_REGISTER Register;
EFI_SMM_IO_TRAP_DISPATCH2_UNREGISTER UnRegister;
};
typedef EFI_MM_IO_TRAP_DISPATCH_UNREGISTER EFI_SMM_IO_TRAP_DISPATCH2_UNREGISTER;
extern EFI_GUID gEfiSmmIoTrapDispatch2ProtocolGuid;

11
MdePkg/Include/Protocol/SmmPciRootBridgeIo.h
View File

@ -3,7 +3,7 @@
This protocol provides PCI I/O and memory access within SMM.
Copyright (c) 2009, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -17,19 +17,16 @@
#ifndef _SMM_PCI_ROOT_BRIDGE_IO_H_
#define _SMM_PCI_ROOT_BRIDGE_IO_H_
#include <Protocol/PciRootBridgeIo.h>
#include <Protocol/MmPciRootBridgeIo.h>
#define EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
{ \
0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea } \
}
#define EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID EFI_MM_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID
///
/// This protocol provides the same functionality as the PCI Root Bridge I/O Protocol defined in the
/// UEFI 2.1 Specifcation, section 13.2, except that the functions for Map() and Unmap() may return
/// EFI_UNSUPPORTED.
///
typedef EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL;
typedef EFI_MM_PCI_ROOT_BRIDGE_IO_PROTOCOL EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL;
extern EFI_GUID gEfiSmmPciRootBridgeIoProtocolGuid;

16
MdePkg/Include/Protocol/SmmPeriodicTimerDispatch2.h
View File

@ -4,7 +4,7 @@
This protocol provides the parent dispatch service for the periodical timer SMI source generator.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -22,11 +22,9 @@
#define _SMM_PERIODIC_TIMER_DISPATCH2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmPeriodicTimerDispatch.h>
#define EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL_GUID \
{ \
0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 } \
}
#define EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL_GUID EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL_GUID
///
/// Example: A chipset supports periodic SMIs on every 64ms or 2 seconds.
@ -66,13 +64,7 @@ typedef struct {
/// Register() in RegisterContext and with CommBuffer pointing to an instance of
/// EFI_SMM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its size.
///
typedef struct {
///
/// ElapsedTime is the actual time in 100 nanosecond units elapsed since last called, a
/// value of 0 indicates an unknown amount of time.
///
UINT64 ElapsedTime;
} EFI_SMM_PERIODIC_TIMER_CONTEXT;
typedef EFI_MM_PERIODIC_TIMER_CONTEXT EFI_SMM_PERIODIC_TIMER_CONTEXT;
typedef struct _EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL;

89
MdePkg/Include/Protocol/SmmPowerButtonDispatch2.h
View File

@ -4,7 +4,7 @@
This protocol provides the parent dispatch service for the power button SMI source generator.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -21,95 +21,20 @@
#ifndef _SMM_POWER_BUTTON_DISPATCH2_H_
#define _SMM_POWER_BUTTON_DISPATCH2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmPowerButtonDispatch.h>
#define EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL_GUID \
{ \
0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d } \
}
///
/// Power Button phases.
///
typedef enum {
EfiPowerButtonEntry,
EfiPowerButtonExit,
EfiPowerButtonMax
} EFI_POWER_BUTTON_PHASE;
#define EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL_GUID EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL_GUID
///
/// The dispatch function's context.
///
typedef struct {
///
/// Designates whether this handler should be invoked upon entry or exit.
///
EFI_POWER_BUTTON_PHASE Phase;
} EFI_SMM_POWER_BUTTON_REGISTER_CONTEXT;
typedef EFI_MM_POWER_BUTTON_REGISTER_CONTEXT EFI_SMM_POWER_BUTTON_REGISTER_CONTEXT;
typedef struct _EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL;
typedef EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL;
/**
Provides the parent dispatch service for a power button event.
typedef EFI_MM_POWER_BUTTON_REGISTER EFI_SMM_POWER_BUTTON_REGISTER2;
This service registers a function (DispatchFunction) which will be called when an SMI is
generated because the power button was pressed or released, as specified by RegisterContext.
On return, DispatchHandle contains a unique handle which may be used later to unregister the
function using UnRegister().
The DispatchFunction will be called with Context set to the same value as was passed into
this function in RegisterContext and with CommBuffer and CommBufferSize set to NULL.
@param[in] This Pointer to the EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when power button is pressed or released.
@param[in] RegisterContext Pointer to the dispatch function's context. The caller fills in this context
before calling the Register() function to indicate to the Register() function
the power button SMI phase for which the dispatch function should be invoked.
@param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. The power button input value
is not within valid range.
@retval EFI_OUT_OF_RESOURCES There is not enough memory (system or SMM) to manage this child.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_POWER_BUTTON_REGISTER2)(
IN CONST EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN EFI_SMM_POWER_BUTTON_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a power-button service.
This service removes the handler associated with DispatchHandle so that it will no longer be
called when the standby button is pressed or released.
@param[in] This Pointer to the EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS The service has been successfully removed.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_POWER_BUTTON_UNREGISTER2)(
IN CONST EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// Interface structure for the SMM Power Button Dispatch2 Protocol.
///
/// This protocol provides the parent dispatch service for the power button SMI source generator.
///
struct _EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL {
EFI_SMM_POWER_BUTTON_REGISTER2 Register;
EFI_SMM_POWER_BUTTON_UNREGISTER2 UnRegister;
};
typedef EFI_MM_POWER_BUTTON_UNREGISTER EFI_SMM_POWER_BUTTON_UNREGISTER2;
extern EFI_GUID gEfiSmmPowerButtonDispatch2ProtocolGuid;

7
MdePkg/Include/Protocol/SmmReadyToLock.h
View File

@ -25,10 +25,9 @@
#ifndef _SMM_READY_TO_LOCK_H_
#define _SMM_READY_TO_LOCK_H_
#define EFI_SMM_READY_TO_LOCK_PROTOCOL_GUID \
{ \
0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 } \
}
#include <Protocol/MmReadyToLock.h>
#define EFI_SMM_READY_TO_LOCK_PROTOCOL_GUID EFI_MM_READY_TO_LOCK_PROTOCOL_GUID
extern EFI_GUID gEfiSmmReadyToLockProtocolGuid;

63
MdePkg/Include/Protocol/SmmReportStatusCodeHandler.h
View File

@ -1,7 +1,7 @@
/** @file
This protocol provides registering and unregistering services to status code consumers while in DXE SMM.
Copyright (c) 2007 - 2009, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -15,66 +15,17 @@
#ifndef __SMM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
#define __SMM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
#define EFI_SMM_RSC_HANDLER_PROTOCOL_GUID \
{ \
0x2ff29fa7, 0x5e80, 0x4ed9, {0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4} \
}
#include <Protocol/MmReportStatusCodeHandler.h>
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_RSC_HANDLER_CALLBACK)(
IN EFI_STATUS_CODE_TYPE CodeType,
IN EFI_STATUS_CODE_VALUE Value,
IN UINT32 Instance,
IN EFI_GUID *CallerId,
IN EFI_STATUS_CODE_DATA *Data
);
#define EFI_SMM_RSC_HANDLER_PROTOCOL_GUID EFI_MM_RSC_HANDLER_PROTOCOL_GUID
/**
Register the callback function for ReportStatusCode() notification.
When this function is called the function pointer is added to an internal list and any future calls to
ReportStatusCode() will be forwarded to the Callback function.
@param[in] Callback A pointer to a function of type EFI_RSC_HANDLER_CALLBACK that is called when
a call to ReportStatusCode() occurs.
typedef EFI_MM_RSC_HANDLER_CALLBACK EFI_SMM_RSC_HANDLER_CALLBACK;
@retval EFI_SUCCESS Function was successfully registered.
@retval EFI_INVALID_PARAMETER The callback function was NULL.
@retval EFI_OUT_OF_RESOURCES The internal buffer ran out of space. No more functions can be
registered.
@retval EFI_ALREADY_STARTED The function was already registered. It can't be registered again.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_RSC_HANDLER_REGISTER)(
IN EFI_SMM_RSC_HANDLER_CALLBACK Callback
);
typedef EFI_MM_RSC_HANDLER_REGISTER EFI_SMM_RSC_HANDLER_REGISTER;
/**
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.
typedef EFI_MM_RSC_HANDLER_UNREGISTER EFI_SMM_RSC_HANDLER_UNREGISTER;
@param[in] Callback A pointer to a function of type EFI_SMM_RSC_HANDLER_CALLBACK that is to be
unregistered.
@retval EFI_SUCCESS The function was successfully unregistered.
@retval EFI_INVALID_PARAMETER The callback function was NULL.
@retval EFI_NOT_FOUND The callback function was not found to be unregistered.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_RSC_HANDLER_UNREGISTER)(
IN EFI_SMM_RSC_HANDLER_CALLBACK Callback
);
typedef struct _EFI_SMM_RSC_HANDLER_PROTOCOL {
EFI_SMM_RSC_HANDLER_REGISTER Register;
EFI_SMM_RSC_HANDLER_UNREGISTER Unregister;
} EFI_SMM_RSC_HANDLER_PROTOCOL;
typedef EFI_MM_RSC_HANDLER_PROTOCOL EFI_SMM_RSC_HANDLER_PROTOCOL;
extern EFI_GUID gEfiSmmRscHandlerProtocolGuid;

89
MdePkg/Include/Protocol/SmmStandbyButtonDispatch2.h
View File

@ -21,97 +21,20 @@
#ifndef _SMM_STANDBY_BUTTON_DISPATCH2_H_
#define _SMM_STANDBY_BUTTON_DISPATCH2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmStandbyButtonDispatch.h>
#define EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL_GUID \
{ \
0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b } \
}
///
/// Standby Button phases
///
typedef enum {
EfiStandbyButtonEntry,
EfiStandbyButtonExit,
EfiStandbyButtonMax
} EFI_STANDBY_BUTTON_PHASE;
#define EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL_GUID EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL_GUID
///
/// The dispatch function's context.
///
typedef struct {
///
/// Describes whether the child handler should be invoked upon the entry to the button
/// activation or upon exit.
///
EFI_STANDBY_BUTTON_PHASE Phase;
} EFI_SMM_STANDBY_BUTTON_REGISTER_CONTEXT;
typedef EFI_MM_STANDBY_BUTTON_REGISTER_CONTEXT EFI_SMM_STANDBY_BUTTON_REGISTER_CONTEXT;
typedef struct _EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL;
typedef EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL;
/**
Provides the parent dispatch service for a standby button event.
typedef EFI_MM_STANDBY_BUTTON_REGISTER EFI_SMM_STANDBY_BUTTON_REGISTER2;
This service registers a function (DispatchFunction) which will be called when an SMI is
generated because the standby button was pressed or released, as specified by
RegisterContext. On return, DispatchHandle contains a unique handle which may be used
later to unregister the function using UnRegister().
The DispatchFunction will be called with Context set to the same value as was passed into
this function in RegisterContext and with CommBuffer and CommBufferSize set to NULL.
@param[in] This Pointer to the EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when the standby button is pressed or released.
@param[in] RegisterContext Pointer to the dispatch function's context. The caller fills in this context
before calling the register function to indicate to the register function the
standby button SMI source for which the dispatch function should be invoked.
@param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. The standby button input value
is not within valid range.
@retval EFI_OUT_OF_RESOURCES There is not enough memory (system or SMM) to manage this child.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STANDBY_BUTTON_REGISTER2)(
IN CONST EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN EFI_SMM_STANDBY_BUTTON_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a child SMI source dispatch function with a parent SMM driver.
This service removes the handler associated with DispatchHandle so that it will no longer be
called when the standby button is pressed or released.
@param[in] This Pointer to the EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS The service has been successfully removed.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STANDBY_BUTTON_UNREGISTER2)(
IN CONST EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// Interface structure for the SMM Standby Button Dispatch2 Protocol.
///
/// This protocol provides the parent dispatch service for the standby
/// button SMI source generator.
///
struct _EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL {
EFI_SMM_STANDBY_BUTTON_REGISTER2 Register;
EFI_SMM_STANDBY_BUTTON_UNREGISTER2 UnRegister;
};
typedef EFI_MM_STANDBY_BUTTON_UNREGISTER EFI_SMM_STANDBY_BUTTON_UNREGISTER2;
extern EFI_GUID gEfiSmmStandbyButtonDispatch2ProtocolGuid;

42
MdePkg/Include/Protocol/SmmStatusCode.h
View File

@ -17,47 +17,13 @@
#ifndef _SMM_STATUS_CODE_H__
#define _SMM_STATUS_CODE_H__
#include <Protocol/MmStatusCode.h>
#define EFI_SMM_STATUS_CODE_PROTOCOL_GUID \
{ \
0x6afd2b77, 0x98c1, 0x4acd, {0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1} \
}
#define EFI_SMM_STATUS_CODE_PROTOCOL_GUID EFI_MM_STATUS_CODE_PROTOCOL_GUID
typedef struct _EFI_SMM_STATUS_CODE_PROTOCOL EFI_SMM_STATUS_CODE_PROTOCOL;
typedef EFI_MM_STATUS_CODE_PROTOCOL EFI_SMM_STATUS_CODE_PROTOCOL;
/**
Service to emit the status code in SMM.
The EFI_SMM_STATUS_CODE_PROTOCOL.ReportStatusCode() function enables a driver
to emit a status code while in SMM. The reason that there is a separate protocol definition from the
DXE variant of this service is that the publisher of this protocol will provide a service that is
capability of coexisting with a foreground operational environment, such as an operating system
after the termination of boot services.
@param[in] This Points to this instance of the EFI_SMM_STATUS_CODE_PROTOCOL.
@param[in] CodeType DIndicates the type of status code being reported.
@param[in] Value Describes the current status of a hardware or software entity.
@param[in] Instance The enumeration of a hardware or software entity within the system.
@param[in] CallerId This optional parameter may be used to identify the caller.
@param[in] Data This optional parameter may be used to pass additional data.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER The function should not be completed due to a device error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_REPORT_STATUS_CODE)(
IN CONST EFI_SMM_STATUS_CODE_PROTOCOL *This,
IN EFI_STATUS_CODE_TYPE CodeType,
IN EFI_STATUS_CODE_VALUE Value,
IN UINT32 Instance,
IN CONST EFI_GUID *CallerId,
IN EFI_STATUS_CODE_DATA *Data OPTIONAL
);
struct _EFI_SMM_STATUS_CODE_PROTOCOL {
EFI_SMM_REPORT_STATUS_CODE ReportStatusCode;
};
typedef EFI_MM_REPORT_STATUS_CODE EFI_SMM_REPORT_STATUS_CODE;
extern EFI_GUID gEfiSmmStatusCodeProtocolGuid;

8
MdePkg/Include/Protocol/SmmSwDispatch2.h
View File

@ -4,7 +4,7 @@
This protocol provides the parent dispatch service for a given SMI source generator.
Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -18,12 +18,10 @@
#ifndef _SMM_SW_DISPATCH2_H_
#define _SMM_SW_DISPATCH2_H_
#include <Protocol/MmSwDispatch.h>
#include <Pi/PiSmmCis.h>
#define EFI_SMM_SW_DISPATCH2_PROTOCOL_GUID \
{ \
0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 } \
}
#define EFI_SMM_SW_DISPATCH2_PROTOCOL_GUID EFI_MM_SW_DISPATCH_PROTOCOL_GUID
///
/// A particular chipset may not support all possible software SMI input values.

111
MdePkg/Include/Protocol/SmmSxDispatch2.h
View File

@ -4,7 +4,7 @@
Provides the parent dispatch service for a given Sx-state source generator.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -18,117 +18,20 @@
#ifndef _SMM_SX_DISPATCH2_H_
#define _SMM_SX_DISPATCH2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmSxDispatch.h>
#define EFI_SMM_SX_DISPATCH2_PROTOCOL_GUID \
{ \
0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d } \
}
///
/// Sleep states S0-S5
///
typedef enum {
SxS0,
SxS1,
SxS2,
SxS3,
SxS4,
SxS5,
EfiMaximumSleepType
} EFI_SLEEP_TYPE;
///
/// Sleep state phase: entry or exit
///
typedef enum {
SxEntry,
SxExit,
EfiMaximumPhase
} EFI_SLEEP_PHASE;
#define EFI_SMM_SX_DISPATCH2_PROTOCOL_GUID EFI_MM_SX_DISPATCH_PROTOCOL_GUID
///
/// The dispatch function's context
///
typedef struct {
EFI_SLEEP_TYPE Type;
EFI_SLEEP_PHASE Phase;
} EFI_SMM_SX_REGISTER_CONTEXT;
typedef EFI_MM_SX_REGISTER_CONTEXT EFI_SMM_SX_REGISTER_CONTEXT;
typedef struct _EFI_SMM_SX_DISPATCH2_PROTOCOL EFI_SMM_SX_DISPATCH2_PROTOCOL;
typedef EFI_MM_SX_DISPATCH_PROTOCOL EFI_SMM_SX_DISPATCH2_PROTOCOL;
/**
Provides the parent dispatch service for a given Sx source generator.
typedef EFI_MM_SX_REGISTER EFI_SMM_SX_REGISTER2;
This service registers a function (DispatchFunction) which will be called when the sleep state
event specified by RegisterContext is detected. On return, DispatchHandle contains a
unique handle which may be used later to unregister the function using UnRegister().
The DispatchFunction will be called with Context set to the same value as was passed into
this function in RegisterContext and with CommBuffer and CommBufferSize set to
NULL and 0 respectively.
@param[in] This Pointer to the EFI_SMM_SX_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when the specified sleep state event occurs.
@param[in] RegisterContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function which Sx state type and phase the caller
wishes to be called back on. For this intertace,
the Sx driver will call the registered handlers for
all Sx type and phases, so the Sx state handler(s)
must check the Type and Phase field of the Dispatch
context and act accordingly.
@param[out] DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_UNSUPPORTED The Sx driver or hardware does not support that
Sx Type/Phase.
@retval EFI_DEVICE_ERROR The Sx driver was unable to enable the SMI source.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. Type & Phase are not
within valid range.
@retval EFI_OUT_OF_RESOURCES There is not enough memory (system or SMM) to manage this
child.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SX_REGISTER2)(
IN CONST EFI_SMM_SX_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN CONST EFI_SMM_SX_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters an Sx-state service.
This service removes the handler associated with DispatchHandle so that it will no longer be
called in response to sleep event.
@param[in] This Pointer to the EFI_SMM_SX_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS The service has been successfully removed.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SX_UNREGISTER2)(
IN CONST EFI_SMM_SX_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// Interface structure for the SMM Sx Dispatch Protocol
///
/// The EFI_SMM_SX_DISPATCH2_PROTOCOL provides the ability to install child handlers to
/// respond to sleep state related events.
///
struct _EFI_SMM_SX_DISPATCH2_PROTOCOL {
EFI_SMM_SX_REGISTER2 Register;
EFI_SMM_SX_UNREGISTER2 UnRegister;
};
typedef EFI_MM_SX_UNREGISTER EFI_SMM_SX_UNREGISTER2;
extern EFI_GUID gEfiSmmSxDispatch2ProtocolGuid;

99
MdePkg/Include/Protocol/SmmUsbDispatch2.h
View File

@ -4,7 +4,7 @@
Provides the parent dispatch service for the USB SMI source generator.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@ -21,108 +21,25 @@
#ifndef _SMM_USB_DISPATCH2_H_
#define _SMM_USB_DISPATCH2_H_
#include <Pi/PiSmmCis.h>
#include <Protocol/MmUsbDispatch.h>
#define EFI_SMM_USB_DISPATCH2_PROTOCOL_GUID \
{ \
0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 } \
}
#define EFI_SMM_USB_DISPATCH2_PROTOCOL_GUID EFI_MM_USB_DISPATCH_PROTOCOL_GUID
///
/// USB SMI event types
///
typedef enum {
UsbLegacy,
UsbWake
} EFI_USB_SMI_TYPE;
typedef EFI_USB_MMI_TYPE EFI_USB_SMI_TYPE;
///
/// The dispatch function's context.
///
typedef struct {
///
/// Describes whether this child handler will be invoked in response to a USB legacy
/// emulation event, such as port-trap on the PS/2* keyboard control registers, or to a
/// USB wake event, such as resumption from a sleep state.
///
EFI_USB_SMI_TYPE Type;
///
/// The device path is part of the context structure and describes the location of the
/// particular USB host controller in the system for which this register event will occur.
/// This location is important because of the possible integration of several USB host
/// controllers in a system.
///
EFI_DEVICE_PATH_PROTOCOL *Device;
} EFI_SMM_USB_REGISTER_CONTEXT;
typedef EFI_MM_USB_REGISTER_CONTEXT EFI_SMM_USB_REGISTER_CONTEXT;
typedef struct _EFI_SMM_USB_DISPATCH2_PROTOCOL EFI_SMM_USB_DISPATCH2_PROTOCOL;
typedef EFI_MM_USB_DISPATCH_PROTOCOL EFI_SMM_USB_DISPATCH2_PROTOCOL;
/**
Provides the parent dispatch service for the USB SMI source generator.
typedef EFI_MM_USB_REGISTER EFI_SMM_USB_REGISTER2;
This service registers a function (DispatchFunction) which will be called when the USB-
related SMI specified by RegisterContext has occurred. On return, DispatchHandle
contains a unique handle which may be used later to unregister the function using UnRegister().
The DispatchFunction will be called with Context set to the same value as was passed into
this function in RegisterContext and with CommBuffer containing NULL and
CommBufferSize containing zero.
@param[in] This Pointer to the EFI_SMM_USB_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when a USB-related SMI occurs.
@param[in] RegisterContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function the USB SMI types for which the dispatch
function should be invoked.
@param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. The USB SMI type
is not within valid range.
@retval EFI_OUT_OF_RESOURCES There is not enough memory (system or SMM) to manage this child.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_USB_REGISTER2)(
IN CONST EFI_SMM_USB_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN CONST EFI_SMM_USB_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a USB service.
This service removes the handler associated with DispatchHandle so that it will no longer be
called when the USB event occurs.
@param[in] This Pointer to the EFI_SMM_USB_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered and the SMI source has been disabled
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_USB_UNREGISTER2)(
IN CONST EFI_SMM_USB_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// Interface structure for the SMM USB SMI Dispatch2 Protocol
///
/// This protocol provides the parent dispatch service for the USB SMI source generator.
///
struct _EFI_SMM_USB_DISPATCH2_PROTOCOL {
EFI_SMM_USB_REGISTER2 Register;
EFI_SMM_USB_UNREGISTER2 UnRegister;
};
typedef EFI_MM_USB_UNREGISTER EFI_SMM_USB_UNREGISTER2;
extern EFI_GUID gEfiSmmUsbDispatch2ProtocolGuid;