From nobody Fri Dec 27 03:18:17 2024 Delivered-To: importer@patchew.org Received-SPF: none (zoho.com: 198.145.21.10 is neither permitted nor denied by domain of lists.01.org) client-ip=198.145.21.10; envelope-from=edk2-devel-bounces@lists.01.org; helo=ml01.01.org; Authentication-Results: mx.zohomail.com; spf=none (zoho.com: 198.145.21.10 is neither permitted nor denied by domain of lists.01.org) smtp.mailfrom=edk2-devel-bounces@lists.01.org Return-Path: Received: from ml01.01.org (ml01.01.org [198.145.21.10]) by mx.zohomail.com with SMTPS id 1503902457197184.2747160766088; Sun, 27 Aug 2017 23:40:57 -0700 (PDT) Received: from [127.0.0.1] (localhost [IPv6:::1]) by ml01.01.org (Postfix) with ESMTP id 42EF821DF8093; Sun, 27 Aug 2017 23:38:16 -0700 (PDT) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 31EE921DF8082 for ; Sun, 27 Aug 2017 23:38:15 -0700 (PDT) Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga105.fm.intel.com with ESMTP; 27 Aug 2017 23:40:53 -0700 Received: from ydong10-win10.ccr.corp.intel.com ([10.239.158.51]) by orsmga002.jf.intel.com with ESMTP; 27 Aug 2017 23:40:51 -0700 X-Original-To: edk2-devel@lists.01.org X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.41,440,1498546800"; d="scan'208";a="128872820" From: Eric Dong To: edk2-devel@lists.01.org Date: Mon, 28 Aug 2017 14:40:47 +0800 Message-Id: <1503902448-7984-2-git-send-email-eric.dong@intel.com> X-Mailer: git-send-email 2.7.0.windows.1 In-Reply-To: <1503902448-7984-1-git-send-email-eric.dong@intel.com> References: <1503902448-7984-1-git-send-email-eric.dong@intel.com> Subject: [edk2] [Patch 1/2] MdePkg: Add new definitions for Management Mode. X-BeenThere: edk2-devel@lists.01.org X-Mailman-Version: 2.1.22 Precedence: list List-Id: EDK II Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Michael D Kinney , Liming Gao MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Errors-To: edk2-devel-bounces@lists.01.org Sender: "edk2-devel" X-ZohoMail: RSF_4 Z_629925259 SPT_0 Content-Type: text/plain; charset="utf-8" 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 Cc: Liming Gao Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Eric Dong --- MdePkg/Include/Pi/PiMmCis.h | 350 +++++++++++++++++= ++++ MdePkg/Include/PiMm.h | 25 ++ MdePkg/Include/Protocol/DxeMmReadyToLock.h | 25 ++ MdePkg/Include/Protocol/MmAccess.h | 133 ++++++++ MdePkg/Include/Protocol/MmBase.h | 87 +++++ MdePkg/Include/Protocol/MmCommunication.h | 83 +++++ MdePkg/Include/Protocol/MmConfiguration.h | 86 +++++ MdePkg/Include/Protocol/MmControl.h | 106 +++++++ MdePkg/Include/Protocol/MmCpu.h | 247 +++++++++++++++ MdePkg/Include/Protocol/MmCpuIo.h | 96 ++++++ MdePkg/Include/Protocol/MmEndOfDxe.h | 30 ++ MdePkg/Include/Protocol/MmGpiDispatch.h | 125 ++++++++ MdePkg/Include/Protocol/MmIoTrapDispatch.h | 136 ++++++++ MdePkg/Include/Protocol/MmPciRootBridgeIo.h | 37 +++ MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h | 170 ++++++++++ MdePkg/Include/Protocol/MmPowerButtonDispatch.h | 117 +++++++ MdePkg/Include/Protocol/MmReadyToLock.h | 32 ++ .../Include/Protocol/MmReportStatusCodeHandler.h | 81 +++++ MdePkg/Include/Protocol/MmStandbyButtonDispatch.h | 119 +++++++ MdePkg/Include/Protocol/MmStatusCode.h | 65 ++++ MdePkg/Include/Protocol/MmSwDispatch.h | 136 ++++++++ MdePkg/Include/Protocol/MmSxDispatch.h | 135 ++++++++ MdePkg/Include/Protocol/MmUsbDispatch.h | 130 ++++++++ MdePkg/MdePkg.dec | 67 ++++ 24 files changed, 2618 insertions(+) create mode 100644 MdePkg/Include/Pi/PiMmCis.h create mode 100644 MdePkg/Include/PiMm.h create mode 100644 MdePkg/Include/Protocol/DxeMmReadyToLock.h create mode 100644 MdePkg/Include/Protocol/MmAccess.h create mode 100644 MdePkg/Include/Protocol/MmBase.h create mode 100644 MdePkg/Include/Protocol/MmCommunication.h create mode 100644 MdePkg/Include/Protocol/MmConfiguration.h create mode 100644 MdePkg/Include/Protocol/MmControl.h create mode 100644 MdePkg/Include/Protocol/MmCpu.h create mode 100644 MdePkg/Include/Protocol/MmCpuIo.h create mode 100644 MdePkg/Include/Protocol/MmEndOfDxe.h create mode 100644 MdePkg/Include/Protocol/MmGpiDispatch.h create mode 100644 MdePkg/Include/Protocol/MmIoTrapDispatch.h create mode 100644 MdePkg/Include/Protocol/MmPciRootBridgeIo.h create mode 100644 MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h create mode 100644 MdePkg/Include/Protocol/MmPowerButtonDispatch.h create mode 100644 MdePkg/Include/Protocol/MmReadyToLock.h create mode 100644 MdePkg/Include/Protocol/MmReportStatusCodeHandler.h create mode 100644 MdePkg/Include/Protocol/MmStandbyButtonDispatch.h create mode 100644 MdePkg/Include/Protocol/MmStatusCode.h create mode 100644 MdePkg/Include/Protocol/MmSwDispatch.h create mode 100644 MdePkg/Include/Protocol/MmSxDispatch.h create mode 100644 MdePkg/Include/Protocol/MmUsbDispatch.h diff --git a/MdePkg/Include/Pi/PiMmCis.h b/MdePkg/Include/Pi/PiMmCis.h new file mode 100644 index 0000000..b066d49 --- /dev/null +++ b/MdePkg/Include/Pi/PiMmCis.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _PI_MMCIS_H_ +#define _PI_MMCIS_H_ + +#include + +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 Managemen= t 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 li= st + must be allocated from pool memory with PoolType set to EfiRuntimeServic= esData. + + @param[in] SystemTable A pointer to the MM System Table (MMST). + @param[in] Guid A pointer to the GUID for the entry to ad= d, update, or remove. + @param[in] Table A pointer to the buffer of the table to a= dd. + @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-exist= ent entry. + @retval EFI_OUT_OF_RESOURCES There is not enough memory available to c= omplete 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 num= ber of the AP + on which the code stream is supposed to r= un. + @param[in,out] ProcArguments Allows the caller to pass a list of param= eters to the code + that is run by the AP. + + @retval EFI_SUCCESS The call was successful and the return pa= rameters are valid. + @retval EFI_INVALID_PARAMETER The input arguments are out of range. + @retval EFI_INVALID_PARAMETER The CPU requested is not available on thi= s SMI invocation. + @retval EFI_INVALID_PARAMETER The CPU cannot support an additional serv= ice 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 interf= ace 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 =3D=3D NULL and Registration is an existing registration, th= en the callback is unhooked. + + @param[in] Protocol The unique ID of the protocol for which th= e 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 rec= ord + 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 r= equest. + @retval EFI_NOT_FOUND If the registration is not found when Func= tion =3D=3D 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 ro= ot MMI handlers. + @param[in] Context Points to an optional context buffer. + @param[in,out] CommBuffer Points to the optional communication buff= er. + @param[in,out] CommBufferSize Points to the size of the optional commun= ication buffer. + + @retval EFI_WARN_INTERRUPT_SOURCE_PENDING Interrupt source was processe= d 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 hand= led 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 callbac= k. + + @param[in] DispatchHandle The unique handle assigned to this handle= r by MmiHandlerRegister(). + @param[in] Context Points to an optional handler context whi= ch was specified when the + handler was registered. + @param[in,out] CommBuffer A pointer to a collection of data in memo= ry that will + be conveyed from a non-MM environment int= o an MM environment. + @param[in,out] CommBufferSize The size of the CommBuffer. + + @retval EFI_SUCCESS The interrupt was handled an= d quiesced. No other handlers + should still be called. + @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quies= ced but other handlers should + still be called. + @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pendi= ng and other handlers should still + be called. + @retval EFI_INTERRUPT_PENDING The interrupt could not be q= uiesced. +**/ +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 ro= ot 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 ha= ndler was registered. + + @retval EFI_SUCCESS Handler function was successfully unregis= tered. + @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 designa= tes 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 enter= ed 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 st= ate. The + /// corresponding element in CpuSaveStateSize specifies the number of by= tes 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 neede= d 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 col= lection of common +/// services for managing MMRAM allocation and providing basic I/O service= s. 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 des= ignates + /// which processor is executing the MM infrastructure. + /// + UINTN CurrentlyExecutingCpu; + /// + /// The number of possible processors in the platform. This is a 1 base= d 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 st= ate. The + /// corresponding element in CpuSaveStateSize specifies the number of by= tes 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 MmConfiguratio= nTable. + /// + UINTN NumberOfTableEntries; + /// + /// A pointer to the UEFI Configuration Tables. The number of entries in= the table is + /// NumberOfTableEntries. + /// + EFI_CONFIGURATION_TABLE *MmConfigurationTable; + + /// + /// Protocol services + /// + EFI_INSTALL_PROTOCOL_INTERFACE MmInstallProtocolInterface; + EFI_UNINSTALL_PROTOCOL_INTERFACE MmUninstallProtocolInterface; + EFI_HANDLE_PROTOCOL MmHandleProtocol; + EFI_MM_REGISTER_PROTOCOL_NOTIFY MmRegisterProtocolNotify; + EFI_LOCATE_HANDLE MmLocateHandle; + EFI_LOCATE_PROTOCOL MmLocateProtocol; + + /// + /// MMI Management functions + /// + EFI_MM_INTERRUPT_MANAGE MmiManage; + EFI_MM_INTERRUPT_REGISTER MmiHandlerRegister; + EFI_MM_INTERRUPT_UNREGISTER MmiHandlerUnRegister; +}; + +#endif diff --git a/MdePkg/Include/PiMm.h b/MdePkg/Include/PiMm.h new file mode 100644 index 0000000..6ee59cc --- /dev/null +++ b/MdePkg/Include/PiMm.h @@ -0,0 +1,25 @@ +/** @file + + Root include file for Mde Package MM modules. + +Copyright (c) 2017, Intel Corporation. All rights reserved.
+This program and the accompanying materials are licensed and made availabl= e under +the terms and conditions of the BSD License that accompanies this distribu= tion. +The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php. + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLI= ED. + +**/ + +#ifndef __PI_MM_H__ +#define __PI_MM_H__ + +#include +#include + +#include + +#endif + diff --git a/MdePkg/Include/Protocol/DxeMmReadyToLock.h b/MdePkg/Include/Pr= otocol/DxeMmReadyToLock.h new file mode 100644 index 0000000..8b61f4d --- /dev/null +++ b/MdePkg/Include/Protocol/DxeMmReadyToLock.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _DXE_MM_READY_TO_LOCK_H_ +#define _DXE_MM_READY_TO_LOCK_H_ + +#define EFI_DXE_MM_READY_TO_LOCK_PROTOCOL_GUID \ + { \ + 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0= , 0x8e } \ + } + +extern EFI_GUID gEfiDxeMmReadyToLockProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmAccess.h b/MdePkg/Include/Protocol/M= mAccess.h new file mode 100644 index 0000000..ad3ed7b --- /dev/null +++ b/MdePkg/Include/Protocol/MmAccess.h @@ -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 plat= form. + 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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#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 closin= g 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 closin= g 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 us= ually 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 Mm= ramMemoryMap 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 b= ridge 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 lo= cked. + /// + BOOLEAN LockState; + /// + /// Indicates the current state of the MMRAM. Set to TRUE if MMRAM is op= en. + /// + BOOLEAN OpenState; +}; + +extern EFI_GUID gEfiMmAccessProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmBase.h b/MdePkg/Include/Protocol/MmB= ase.h new file mode 100644 index 0000000..a84c587 --- /dev/null +++ b/MdePkg/Include/Protocol/MmBase.h @@ -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 infrastruct= ure services and determine + whether the driver is being invoked inside MMRAM or outside of MMRAM. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_BASE_H_ +#define _MM_BASE_H_ + +#include + +#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 executi= ng 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, in= dicates 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 e= ntry point and then cache it in + some driver global variable so that the MMST can be invoked in subsequen= t handlers. + + @param[in] This The EFI_MM_BASE_PROTOCOL instance. + @param[in,out] Mmst On return, points to a pointer to the Man= agement 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 in= frastructure +/// services and determine whether the driver is being invoked inside MMRA= M or outside of MMRAM. +/// +struct _EFI_MM_BASE_PROTOCOL { + EFI_MM_INSIDE_OUT InMm; + EFI_MM_GET_MMST_LOCATION GetMmstLocation; +}; + +extern EFI_GUID gEfiMmBaseProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmCommunication.h b/MdePkg/Include/Pro= tocol/MmCommunication.h new file mode 100644 index 0000000..16450e3 --- /dev/null +++ b/MdePkg/Include/Protocol/MmCommunication.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_COMMUNICATION_H_ +#define _MM_COMMUNICATION_H_ + +#pragma pack(1) + +/// +/// To avoid confusion in interpreting frames, the communication buffer sh= ould 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_PROTOC= OL; + +/** + Communicates with a registered handler. + + This function provides a service to send and receive messages from a reg= istered UEFI service. + + @param[in] This The EFI_MM_COMMUNICATION_PROTOCOL instanc= e. + @param[in] CommBuffer A pointer to the buffer to convey into MM= RAM. + @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 communicat= ing +/// between DXE drivers and a registered MMI handler. +/// +struct _EFI_MM_COMMUNICATION_PROTOCOL { + EFI_MM_COMMUNICATE Communicate; +}; + +extern EFI_GUID gEfiMmCommunicationProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmConfiguration.h b/MdePkg/Include/Pro= tocol/MmConfiguration.h new file mode 100644 index 0000000..4719186 --- /dev/null +++ b/MdePkg/Include/Protocol/MmConfiguration.h @@ -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 MMR= AM heap. + 2) register the MM Foundation entry point with the processor code. The e= ntry + point will be invoked by the MM processor entry code. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_CONFIGURATION_H_ +#define _MM_CONFIGURATION_H_ + +#include + +#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 MMR= AM 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_PROTOC= OL; + +/** + 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 instanc= e. + @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 registe= r the MM +/// Foundation entry point with the MM entry vector code. +/// +struct _EFI_MM_CONFIGURATION_PROTOCOL { + /// + /// A pointer to an array MMRAM ranges used by the initial MM entry code. + /// + EFI_MM_RESERVED_MMRAM_REGION *MmramReservedRegions; + EFI_MM_REGISTER_MM_ENTRY RegisterMmEntry; +}; + +extern EFI_GUID gEfiMmConfigurationProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmControl.h b/MdePkg/Include/Protocol/= MmControl.h new file mode 100644 index 0000000..1461137 --- /dev/null +++ b/MdePkg/Include/Protocol/MmControl.h @@ -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 protoco= l 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 I= A-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 o= ften 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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_CONTROL_H_ +#define _MM_CONTROL_H_ + +#include + +#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 peri= odic stream. + @param[in] ActivationInterval Optional parameter to repeat at this = period one + time or, if the Periodic Boolean is s= et, 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 initiali= zed. +**/ +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() ca= ll. + + This function acknowledges and causes the deassertion of the MMI activat= ion source. + + @param[in] This The EFI_MM_CONTROL_PROTOCOL instance. + @param[in] Periodic Optional parameter to repeat at this peri= od 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 provid= es 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 suppor= ts 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 maximu= m is not + /// specified in that the MM infrastructure code can emulate a maximum i= nterval that is + /// greater than the hardware capabilities by using software emulation i= n the MM + /// infrastructure code. + /// + EFI_MM_PERIOD MinimumTriggerPeriod; +}; + +extern EFI_GUID gEfiMmControlProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmCpu.h b/MdePkg/Include/Protocol/MmCp= u.h new file mode 100644 index 0000000..c62037f --- /dev/null +++ b/MdePkg/Include/Protocol/MmCpu.h @@ -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 register= s 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 thi= s information in a standard + format. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#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 =3D 4, + EFI_MM_SAVE_STATE_REGISTER_IDTBASE =3D 5, + EFI_MM_SAVE_STATE_REGISTER_LDTBASE =3D 6, + EFI_MM_SAVE_STATE_REGISTER_GDTLIMIT =3D 7, + EFI_MM_SAVE_STATE_REGISTER_IDTLIMIT =3D 8, + EFI_MM_SAVE_STATE_REGISTER_LDTLIMIT =3D 9, + EFI_MM_SAVE_STATE_REGISTER_LDTINFO =3D 10, + EFI_MM_SAVE_STATE_REGISTER_ES =3D 20, + EFI_MM_SAVE_STATE_REGISTER_CS =3D 21, + EFI_MM_SAVE_STATE_REGISTER_SS =3D 22, + EFI_MM_SAVE_STATE_REGISTER_DS =3D 23, + EFI_MM_SAVE_STATE_REGISTER_FS =3D 24, + EFI_MM_SAVE_STATE_REGISTER_GS =3D 25, + EFI_MM_SAVE_STATE_REGISTER_LDTR_SEL =3D 26, + EFI_MM_SAVE_STATE_REGISTER_TR_SEL =3D 27, + EFI_MM_SAVE_STATE_REGISTER_DR7 =3D 28, + EFI_MM_SAVE_STATE_REGISTER_DR6 =3D 29, + EFI_MM_SAVE_STATE_REGISTER_R8 =3D 30, + EFI_MM_SAVE_STATE_REGISTER_R9 =3D 31, + EFI_MM_SAVE_STATE_REGISTER_R10 =3D 32, + EFI_MM_SAVE_STATE_REGISTER_R11 =3D 33, + EFI_MM_SAVE_STATE_REGISTER_R12 =3D 34, + EFI_MM_SAVE_STATE_REGISTER_R13 =3D 35, + EFI_MM_SAVE_STATE_REGISTER_R14 =3D 36, + EFI_MM_SAVE_STATE_REGISTER_R15 =3D 37, + EFI_MM_SAVE_STATE_REGISTER_RAX =3D 38, + EFI_MM_SAVE_STATE_REGISTER_RBX =3D 39, + EFI_MM_SAVE_STATE_REGISTER_RCX =3D 40, + EFI_MM_SAVE_STATE_REGISTER_RDX =3D 41, + EFI_MM_SAVE_STATE_REGISTER_RSP =3D 42, + EFI_MM_SAVE_STATE_REGISTER_RBP =3D 43, + EFI_MM_SAVE_STATE_REGISTER_RSI =3D 44, + EFI_MM_SAVE_STATE_REGISTER_RDI =3D 45, + EFI_MM_SAVE_STATE_REGISTER_RIP =3D 46, + EFI_MM_SAVE_STATE_REGISTER_RFLAGS =3D 51, + EFI_MM_SAVE_STATE_REGISTER_CR0 =3D 52, + EFI_MM_SAVE_STATE_REGISTER_CR3 =3D 53, + EFI_MM_SAVE_STATE_REGISTER_CR4 =3D 54, + EFI_MM_SAVE_STATE_REGISTER_FCW =3D 256, + EFI_MM_SAVE_STATE_REGISTER_FSW =3D 257, + EFI_MM_SAVE_STATE_REGISTER_FTW =3D 258, + EFI_MM_SAVE_STATE_REGISTER_OPCODE =3D 259, + EFI_MM_SAVE_STATE_REGISTER_FP_EIP =3D 260, + EFI_MM_SAVE_STATE_REGISTER_FP_CS =3D 261, + EFI_MM_SAVE_STATE_REGISTER_DATAOFFSET =3D 262, + EFI_MM_SAVE_STATE_REGISTER_FP_DS =3D 263, + EFI_MM_SAVE_STATE_REGISTER_MM0 =3D 264, + EFI_MM_SAVE_STATE_REGISTER_MM1 =3D 265, + EFI_MM_SAVE_STATE_REGISTER_MM2 =3D 266, + EFI_MM_SAVE_STATE_REGISTER_MM3 =3D 267, + EFI_MM_SAVE_STATE_REGISTER_MM4 =3D 268, + EFI_MM_SAVE_STATE_REGISTER_MM5 =3D 269, + EFI_MM_SAVE_STATE_REGISTER_MM6 =3D 270, + EFI_MM_SAVE_STATE_REGISTER_MM7 =3D 271, + EFI_MM_SAVE_STATE_REGISTER_XMM0 =3D 272, + EFI_MM_SAVE_STATE_REGISTER_XMM1 =3D 273, + EFI_MM_SAVE_STATE_REGISTER_XMM2 =3D 274, + EFI_MM_SAVE_STATE_REGISTER_XMM3 =3D 275, + EFI_MM_SAVE_STATE_REGISTER_XMM4 =3D 276, + EFI_MM_SAVE_STATE_REGISTER_XMM5 =3D 277, + EFI_MM_SAVE_STATE_REGISTER_XMM6 =3D 278, + EFI_MM_SAVE_STATE_REGISTER_XMM7 =3D 279, + EFI_MM_SAVE_STATE_REGISTER_XMM8 =3D 280, + EFI_MM_SAVE_STATE_REGISTER_XMM9 =3D 281, + EFI_MM_SAVE_STATE_REGISTER_XMM10 =3D 282, + EFI_MM_SAVE_STATE_REGISTER_XMM11 =3D 283, + EFI_MM_SAVE_STATE_REGISTER_XMM12 =3D 284, + EFI_MM_SAVE_STATE_REGISTER_XMM13 =3D 285, + EFI_MM_SAVE_STATE_REGISTER_XMM14 =3D 286, + EFI_MM_SAVE_STATE_REGISTER_XMM15 =3D 287, + /// + /// Pseudo-Registers + /// + EFI_MM_SAVE_STATE_REGISTER_IO =3D 512, + EFI_MM_SAVE_STATE_REGISTER_LMA =3D 513, + EFI_MM_SAVE_STATE_REGISTER_PROCESSOR_ID =3D 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 =3D 0, + EFI_MM_SAVE_STATE_IO_WIDTH_UINT16 =3D 1, + EFI_MM_SAVE_STATE_IO_WIDTH_UINT32 =3D 2, + EFI_MM_SAVE_STATE_IO_WIDTH_UINT64 =3D 3 +} EFI_MM_SAVE_STATE_IO_WIDTH; + +/// +/// Types of I/O instruction +/// +typedef enum { + EFI_MM_SAVE_STATE_IO_TYPE_INPUT =3D 1, + EFI_MM_SAVE_STATE_IO_TYPE_OUTPUT =3D 2, + EFI_MM_SAVE_STATE_IO_TYPE_STRING =3D 4, + EFI_MM_SAVE_STATE_IO_TYPE_REP_PREFIX =3D 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 t= he MMI was generated. +/// +typedef struct _EFI_MM_SAVE_STATE_IO_INFO { + /// + /// For input instruction (IN, INS), this is data read before the MMI oc= curred. For output + /// instructions (OUT, OUTS) this is data that was written before the MM= I 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 speci= fied 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 i= s 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 t= he 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 examp= le, 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 spec= ified register to the CPU save + state of the specified CPU and place the value into the buffer. If the C= PU 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 i= s returned. + + @param[in] This The EFI_MM_CPU_PROTOCOL instance. + @param[in] Width The number of bytes to write to the CPU s= ave state. + @param[in] Register Specifies the CPU register to write to th= e 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 regist= er 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 examp= le: + 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 i= n MM. +/// +/// This protocol allows MM drivers to access architecture-standard regist= ers from any of the CPU +/// save state areas. In some cases, difference processors provide the sam= e information in the save state, +/// but not in the same format. These so-called pseudo-registers provide t= his information in a standard +/// format. +/// +struct _EFI_MM_CPU_PROTOCOL { + EFI_MM_READ_SAVE_STATE ReadSaveState; + EFI_MM_WRITE_SAVE_STATE WriteSaveState; +}; + +extern EFI_GUID gEfiMmCpuProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmCpuIo.h b/MdePkg/Include/Protocol/Mm= CpuIo.h new file mode 100644 index 0000000..646480e --- /dev/null +++ b/MdePkg/Include/Protocol/MmCpuIo.h @@ -0,0 +1,96 @@ +/** @file + MM CPU I/O 2 protocol as defined in the PI 1.5 specification. + + This protocol provides CPU I/O and memory access within MM. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#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 =3D 0, + MM_IO_UINT16 =3D 1, + MM_IO_UINT32 =3D 2, + MM_IO_UINT64 =3D 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 ca= ller is + responsible for aligning the Address if require= d. + @param[in] Count The number of I/O operations to perform. + @param[in,out] Buffer For read operations, the destination buffer to = store + the results. For write operations, the source = buffer + from which to write data. + + @retval EFI_SUCCESS The data was read from or written to the = device. + @retval EFI_UNSUPPORTED The Address is not valid for this system. + @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid. + @retval EFI_OUT_OF_RESOURCES The request could not be completed due to= a lack + of resources. +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_CPU_IO)( + IN CONST EFI_MM_CPU_IO_PROTOCOL *This, + IN EFI_MM_IO_WIDTH Width, + IN UINT64 Address, + IN UINTN Count, + IN OUT VOID *Buffer + ); + +typedef struct { + /// + /// This service provides the various modalities of memory and I/O read. + /// + EFI_MM_CPU_IO Read; + /// + /// This service provides the various modalities of memory and I/O write. + /// + EFI_MM_CPU_IO Write; +} EFI_MM_IO_ACCESS; + +/// +/// MM CPU I/O Protocol provides CPU I/O and memory access within MM. +/// +struct _EFI_MM_CPU_IO_PROTOCOL { + /// + /// Allows reads and writes to memory-mapped I/O space. + /// + EFI_MM_IO_ACCESS Mem; + /// + /// Allows reads and writes to I/O space. + /// + EFI_MM_IO_ACCESS Io; +}; + +extern EFI_GUID gEfiMmCpuIoProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmEndOfDxe.h b/MdePkg/Include/Protocol= /MmEndOfDxe.h new file mode 100644 index 0000000..f110d0f --- /dev/null +++ b/MdePkg/Include/Protocol/MmEndOfDxe.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_END_OF_DXE_H_ +#define _MM_END_OF_DXE_H_ + +#define EFI_MM_END_OF_DXE_PROTOCOL_GUID \ + { \ + 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9,= 0x3d } \ + } + +extern EFI_GUID gEfiMmEndOfDxeProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmGpiDispatch.h b/MdePkg/Include/Proto= col/MmGpiDispatch.h new file mode 100644 index 0000000..87db7a0 --- /dev/null +++ b/MdePkg/Include/Protocol/MmGpiDispatch.h @@ -0,0 +1,125 @@ +/** @file + MM General Purpose Input (GPI) Dispatch Protocol as defined in PI 1.5 Sp= ecification + Volume 4 Management Mode Core Interface. + + This protocol provides the parent dispatch service for the General Purpo= se Input + (GPI) MMI source generator. + + The EFI_MM_GPI_DISPATCH_PROTOCOL provides the ability to install child h= andlers 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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + + @par Revision Reference: + This protocol is from PI Version 1.5. + +**/ + +#ifndef _MM_GPI_DISPATCH_H_ +#define _MM_GPI_DISPATCH_H_ + +#include + +#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 calle= d when an MMI is + generated because of one or more of the GPIs specified by RegisterContex= t. On return, + DispatchHandle contains a unique handle which may be used later to unreg= ister the function + using UnRegister(). + The DispatchFunction will be called with Context set to the same value a= s 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 th= e MMI and + CommBufferSize pointing to the size of the structure. + + @param[in] This Pointer to the EFI_MM_GPI_DISPATCH_PROTOC= OL 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 contex= t. + The caller fills this context in before c= alling + the register function to indicate to the = register + function the GPI(s) for which the dispatc= h function + should be invoked. + @param[out] DispatchHandle Handle generated by the dispatcher to tra= ck the + function instance. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI s= ource. + @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_PROTOC= OL instance. + @param[in] DispatchHandle Handle of the service to remove. + + @retval EFI_SUCCESS Handle of the service to remove. + @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid. +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_GPI_UNREGISTER)( + IN CONST EFI_MM_GPI_DISPATCH_PROTOCOL *This, + IN EFI_HANDLE DispatchHandle + ); + +/// +/// Interface structure for the MM GPI MMI Dispatch Protocol +/// +/// The MM GPI MMI Dispatch Protocol provides the parent dispatch service +/// for the General Purpose Input (GPI) MMI source generator. +/// +struct _EFI_MM_GPI_DISPATCH_PROTOCOL { + EFI_MM_GPI_REGISTER Register; + EFI_MM_GPI_UNREGISTER UnRegister; + /// + /// Denotes the maximum value of inputs that can have handlers attached. + /// + UINTN NumSupportedGpis; +}; + +extern EFI_GUID gEfiMmGpiDispatchProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmIoTrapDispatch.h b/MdePkg/Include/Pr= otocol/MmIoTrapDispatch.h new file mode 100644 index 0000000..be0098b --- /dev/null +++ b/MdePkg/Include/Protocol/MmIoTrapDispatch.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + + @par Revision Reference: + This protocol is from PI Version 1.5. + +**/ + +#ifndef _MM_IO_TRAP_DISPATCH_H_ +#define _MM_IO_TRAP_DISPATCH_H_ + +#include + +#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 tha= t occurred +/// +typedef struct { + UINT32 WriteData; +} EFI_MM_IO_TRAP_CONTEXT; + +typedef struct _EFI_MM_IO_TRAP_DISPATCH_PROTOCOL EFI_MM_IO_TRAP_DISPATCH_P= ROTOCOL; + +/** + Register an IO trap MMI child handler for a specified MMI. + + This service registers a function (DispatchFunction) which will be calle= d when an MMI is + generated because of an access to an I/O port specified by RegisterConte= xt. On return, + DispatchHandle contains a unique handle which may be used later to unreg= ister 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 f= ield 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-z= ero or + EFI_MM_READY_TO_LOCK has been installed. In this case, the caller is re= sponsible for the + existence and allocation of the specific IO range. + An error may be returned if some or all of the requested resources confl= ict 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 info= rmation + concerning the I/O action that actually happened and is passed in Regist= erContext, with + CommBuffer pointing to the data actually written and CommBufferSize poin= ting to the size of + the data in CommBuffer. + + @param[in] This Pointer to the EFI_MM_IO_TRAP_DISPATCH_PR= OTOCOL 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 contex= t. The caller fills this + context in before calling the register fu= nction 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 successful= ly 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 f= ulfill the IO trap range request. + @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The input va= lue 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_PR= OTOCOL instance. + @param[in] DispatchHandle Handle of the child service to remove. + + @retval EFI_SUCCESS The dispatch function has been successful= ly 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 sourc= es. +/// +struct _EFI_MM_IO_TRAP_DISPATCH_PROTOCOL { + EFI_MM_IO_TRAP_DISPATCH_REGISTER Register; + EFI_MM_IO_TRAP_DISPATCH_UNREGISTER UnRegister; +}; + +extern EFI_GUID gEfiMmIoTrapDispatchProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmPciRootBridgeIo.h b/MdePkg/Include/P= rotocol/MmPciRootBridgeIo.h new file mode 100644 index 0000000..1de9931 --- /dev/null +++ b/MdePkg/Include/Protocol/MmPciRootBridgeIo.h @@ -0,0 +1,37 @@ +/** @file + MM PCI Root Bridge IO protocol as defined in the PI 1.5 specification. + + This protocol provides PCI I/O and memory access within MM. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_PCI_ROOT_BRIDGE_IO_H_ +#define _MM_PCI_ROOT_BRIDGE_IO_H_ + +#include + +#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_PROTOCO= L; + +extern EFI_GUID gEfiMmPciRootBridgeIoProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h b/MdePkg/Inc= lude/Protocol/MmPeriodicTimerDispatch.h new file mode 100644 index 0000000..2a8cc38 --- /dev/null +++ b/MdePkg/Include/Protocol/MmPeriodicTimerDispatch.h @@ -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 ti= mer MMI source generator. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + + @par Revision Reference: + This protocol is from PI Version 1.5. + +**/ + +#ifndef _MM_PERIODIC_TIMER_DISPATCH_H_ +#define _MM_PERIODIC_TIMER_DISPATCH_H_ + +#include + +#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 second= s, there +/// are several ways to approach the problem: +/// 1. The child may accept a 4 second periodic rate, in which case it r= egisters with +/// Period =3D 40000 +/// MmiTickInterval =3D 20000 +/// The resulting MMI will occur every 2 seconds with the child calle= d back on +/// every 2nd MMI. +/// NOTE: the same result would occur if the child set MmiTickInterva= l =3D 0. +/// 2. The child may choose the finer granularity MMI (64ms): +/// Period =3D 30000 +/// MmiTickInterval =3D 640 +/// The resulting MMI will occur every 64ms with the child called bac= k on +/// every 47th MMI. +/// NOTE: the child driver should be aware that this will result in m= ore +/// 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 ge= ts 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 gra= nularity 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 insta= nce 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_T= IMER_DISPATCH_PROTOCOL; + +/** + Register a child MMI source dispatch function for MM periodic timer. + + This service registers a function (DispatchFunction) which will be calle= d when at least the + amount of time specified by RegisterContext has elapsed. On return, Disp= atchHandle + contains a unique handle which may be used later to unregister the funct= ion using UnRegister(). + The DispatchFunction will be called with Context set to the same value a= s was passed into + this function in RegisterContext and with CommBuffer pointing to an inst= ance of + EFI_MM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its size. + + @param[in] This Pointer to the EFI_MM_PERIODIC_TIMER_DISP= ATCH_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 contex= t. + The caller fills this context in before c= alling + 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 tra= ck the function instance. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI s= ource. + @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The period in= put 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_DISP= ATCH_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_DIS= PATCH_PROTOCOL instance. + @param[in,out] MmiTickInterval Pointer to pointer of next shorter MMI i= nterval + period supported by the child. This para= meter works as a get-first, + get-next field.The first time this funct= ion 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 *MmiT= ickInterval =3D NULL. + + @retval EFI_SUCCESS The service returned successfully. +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_PERIODIC_TIMER_INTERVAL)( + IN CONST EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This, + IN OUT UINT64 **MmiTickInterval + ); + +/// +/// Interface structure for the MM Periodic Timer Dispatch Protocol +/// +/// This protocol provides the parent dispatch service for the periodical = timer MMI source generator. +/// +struct _EFI_MM_PERIODIC_TIMER_DISPATCH_PROTOCOL { + EFI_MM_PERIODIC_TIMER_REGISTER Register; + EFI_MM_PERIODIC_TIMER_UNREGISTER UnRegister; + EFI_MM_PERIODIC_TIMER_INTERVAL GetNextShorterInterval; +}; + +extern EFI_GUID gEfiMmPeriodicTimerDispatchProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmPowerButtonDispatch.h b/MdePkg/Inclu= de/Protocol/MmPowerButtonDispatch.h new file mode 100644 index 0000000..b8a12f5 --- /dev/null +++ b/MdePkg/Include/Protocol/MmPowerButtonDispatch.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + + @par Revision Reference: + This protocol is from PI Version 1.5. + +**/ + +#ifndef _MM_POWER_BUTTON_DISPATCH_H_ +#define _MM_POWER_BUTTON_DISPATCH_H_ + +#include + +#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 calle= d 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 lat= er to unregister the + function using UnRegister(). + The DispatchFunction will be called with Context set to the same value a= s 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_DISPAT= CH_PROTOCOL instance. + @param[in] DispatchFunction Function to register for handler when pow= er button is pressed or released. + @param[in] RegisterContext Pointer to the dispatch function's contex= t. 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 tra= ck the function instance. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI s= ource. + @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The power but= ton 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_DISPAT= CH_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 butto= n MMI source generator. +/// +struct _EFI_MM_POWER_BUTTON_DISPATCH_PROTOCOL { + EFI_MM_POWER_BUTTON_REGISTER Register; + EFI_MM_POWER_BUTTON_UNREGISTER UnRegister; +}; + +extern EFI_GUID gEfiMmPowerButtonDispatchProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmReadyToLock.h b/MdePkg/Include/Proto= col/MmReadyToLock.h new file mode 100644 index 0000000..a9a1af4 --- /dev/null +++ b/MdePkg/Include/Protocol/MmReadyToLock.h @@ -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 interfac= es + 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 environme= nt. + This protocol is installed after installation of the MM End of DXE Proto= col. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_READY_TO_LOCK_H_ +#define _MM_READY_TO_LOCK_H_ + +#define EFI_MM_READY_TO_LOCK_PROTOCOL_GUID \ + { \ + 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2= , 0xc8 } \ + } + +extern EFI_GUID gEfiMmReadyToLockProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h b/MdePkg/I= nclude/Protocol/MmReportStatusCodeHandler.h new file mode 100644 index 0000000..4037d72 --- /dev/null +++ b/MdePkg/Include/Protocol/MmReportStatusCodeHandler.h @@ -0,0 +1,81 @@ +/** @file + This protocol provides registering and unregistering services to status = code consumers while in DXE MM. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#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 interna= l 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. I= t 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 l= ist. + + 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 ExitBootSe= rvices() is called. + + @param[in] Callback A pointer to a function of type EFI_MM_RSC= _HANDLER_CALLBACK that is to be + unregistered. + + @retval EFI_SUCCESS The function was successfully unregistered. + @retval EFI_INVALID_PARAMETER The callback function was NULL. + @retval EFI_NOT_FOUND The callback function was not found to be = unregistered. + +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_RSC_HANDLER_UNREGISTER)( + IN EFI_MM_RSC_HANDLER_CALLBACK Callback +); + +typedef struct _EFI_MM_RSC_HANDLER_PROTOCOL { + EFI_MM_RSC_HANDLER_REGISTER Register; + EFI_MM_RSC_HANDLER_UNREGISTER Unregister; +} EFI_MM_RSC_HANDLER_PROTOCOL; + +extern EFI_GUID gEfiMmRscHandlerProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h b/MdePkg/Inc= lude/Protocol/MmStandbyButtonDispatch.h new file mode 100644 index 0000000..dc95e8f --- /dev/null +++ b/MdePkg/Include/Protocol/MmStandbyButtonDispatch.h @@ -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 butto= n MMI source generator. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + + @par Revision Reference: + This protocol is from PI Version 1.5. + +**/ + +#ifndef _MM_STANDBY_BUTTON_DISPATCH_H_ +#define _MM_STANDBY_BUTTON_DISPATCH_H_ + +#include + +#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_BUT= TON_DISPATCH_PROTOCOL; + +/** + Provides the parent dispatch service for a standby button event. + + This service registers a function (DispatchFunction) which will be calle= d when an MMI is + generated because the standby button was pressed or released, as specifi= ed by + RegisterContext. On return, DispatchHandle contains a unique handle whic= h may be used + later to unregister the function using UnRegister(). + The DispatchFunction will be called with Context set to the same value a= s 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_DISP= ATCH_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 contex= t. The caller fills in this context + before calling the register function to i= ndicate to the register function the + standby button MMI source for which the d= ispatch function should be invoked. + @param[out] DispatchHandle Handle generated by the dispatcher to tra= ck the function instance. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI s= ource. + @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The standby b= utton 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_DISP= ATCH_PROTOCOL instance. + @param[in] DispatchHandle Handle of the service to remove. + + @retval EFI_SUCCESS The service has been successfully removed. + @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid. +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_STANDBY_BUTTON_UNREGISTER)( + IN CONST EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This, + IN EFI_HANDLE DispatchHandle + ); + +/// +/// Interface structure for the MM Standby Button Dispatch Protocol. +/// +/// This protocol provides the parent dispatch service for the standby +/// button MMI source generator. +/// +struct _EFI_MM_STANDBY_BUTTON_DISPATCH_PROTOCOL { + EFI_MM_STANDBY_BUTTON_REGISTER Register; + EFI_MM_STANDBY_BUTTON_UNREGISTER UnRegister; +}; + +extern EFI_GUID gEfiMmStandbyButtonDispatchProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmStatusCode.h b/MdePkg/Include/Protoc= ol/MmStatusCode.h new file mode 100644 index 0000000..adebaee --- /dev/null +++ b/MdePkg/Include/Protocol/MmStatusCode.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#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 dr= iver + 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_STA= TUS_CODE_PROTOCOL. + @param[in] CodeType DIndicates the type of status code being = reported. + @param[in] Value Describes the current status of a hardwar= e 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 id= entify the caller. + @param[in] Data This optional parameter may be used to pa= ss additional data. + + @retval EFI_SUCCESS The function completed successfully. + @retval EFI_INVALID_PARAMETER The function should not be completed due = to a device error. +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_REPORT_STATUS_CODE)( + IN CONST EFI_MM_STATUS_CODE_PROTOCOL *This, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN CONST EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + +struct _EFI_MM_STATUS_CODE_PROTOCOL { + EFI_MM_REPORT_STATUS_CODE ReportStatusCode; +}; + +extern EFI_GUID gEfiMmStatusCodeProtocolGuid; + +#endif + diff --git a/MdePkg/Include/Protocol/MmSwDispatch.h b/MdePkg/Include/Protoc= ol/MmSwDispatch.h new file mode 100644 index 0000000..d3acb64 --- /dev/null +++ b/MdePkg/Include/Protocol/MmSwDispatch.h @@ -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 sourc= e generator. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_SW_DISPATCH2_H_ +#define _MM_SW_DISPATCH2_H_ + +#include + +#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 v= alues. +/// For example, the ICH supports only values 00h to 0FFh. The parent onl= y 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 CommBufferSi= ze) pointing +/// to an instance of EFI_MM_SW_CONTEXT indicating the index of the CPU wh= ich 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 th= e 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 calle= d when the software + MMI source specified by RegisterContext->SwMmiCpuIndex is detected. On r= eturn, + DispatchHandle contains a unique handle which may be used later to unreg= ister the function + using UnRegister(). + + @param[in] This Pointer to the EFI_MM_SW_DISPATCH_PROTO= COL instance. + @param[in] DispatchFunction Function to register for handler when t= he specified software + MMI is generated. + @param[in, out] RegisterContext Pointer to the dispatch function's cont= ext. + The caller fills this context in before= calling + the register function to indicate to th= e register + function which Software MMI input value= the + dispatch function should be invoked for. + @param[out] DispatchHandle Handle generated by the dispatcher to t= rack the + function instance. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_DEVICE_ERROR The SW driver was unable to enable the MM= I source. + @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The SW MMI in= put 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 softwa= re 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_PROTOCO= L instance. + @param[in] DispatchHandle Handle of dispatch function to deregister. + + @retval EFI_SUCCESS The dispatch function has been successful= ly 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, a= nd the maximum software +/// interrupt in the EFI_MM_SW_REGISTER_CONTEXT is denoted by MaximumSwiVa= lue. +/// +struct _EFI_MM_SW_DISPATCH_PROTOCOL { + EFI_MM_SW_REGISTER Register; + EFI_MM_SW_UNREGISTER UnRegister; + /// + /// A read-only field that describes the maximum value that can be used = in the + /// EFI_MM_SW_DISPATCH_PROTOCOL.Register() service. + /// + UINTN MaximumSwiValue; +}; + +extern EFI_GUID gEfiMmSwDispatchProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmSxDispatch.h b/MdePkg/Include/Protoc= ol/MmSxDispatch.h new file mode 100644 index 0000000..acceb89 --- /dev/null +++ b/MdePkg/Include/Protocol/MmSxDispatch.h @@ -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 generat= or. + + Copyright (c) 2017, Intel Corporation. All rights reserved.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _MM_SX_DISPATCH_H_ +#define _MM_SX_DISPATCH_H_ + +#include + +#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 calle= d when the sleep state + event specified by RegisterContext is detected. On return, DispatchHandl= e contains a + unique handle which may be used later to unregister the function using U= nRegister(). + The DispatchFunction will be called with Context set to the same value a= s 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_PROTOCO= L 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 contex= t. + The caller fills this context in before c= alling + the register function to indicate to the = register + function which Sx state type and phase th= e caller + wishes to be called back on. For this int= ertace, + the Sx driver will call the registered ha= ndlers for + all Sx type and phases, so the Sx state h= andler(s) + must check the Type and Phase field of th= e Dispatch + context and act accordingly. + @param[out] DispatchHandle Handle of dispatch function, for when int= erfacing + with the parent Sx state MM driver. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_UNSUPPORTED The Sx driver or hardware does not suppor= t that + Sx Type/Phase. + @retval EFI_DEVICE_ERROR The Sx driver was unable to enable the MM= I 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_PROTOCO= L instance. + @param[in] DispatchHandle Handle of the service to remove. + + @retval EFI_SUCCESS The service has been successfully removed. + @retval EFI_INVALID_PARAMETER The DispatchHandle was not valid. +**/ +typedef +EFI_STATUS +(EFIAPI *EFI_MM_SX_UNREGISTER)( + IN CONST EFI_MM_SX_DISPATCH_PROTOCOL *This, + IN EFI_HANDLE DispatchHandle + ); + +/// +/// Interface structure for the MM Sx Dispatch Protocol +/// +/// The EFI_MM_SX_DISPATCH_PROTOCOL provides the ability to install child = handlers to +/// respond to sleep state related events. +/// +struct _EFI_MM_SX_DISPATCH_PROTOCOL { + EFI_MM_SX_REGISTER Register; + EFI_MM_SX_UNREGISTER UnRegister; +}; + +extern EFI_GUID gEfiMmSxDispatchProtocolGuid; + +#endif diff --git a/MdePkg/Include/Protocol/MmUsbDispatch.h b/MdePkg/Include/Proto= col/MmUsbDispatch.h new file mode 100644 index 0000000..6684287 --- /dev/null +++ b/MdePkg/Include/Protocol/MmUsbDispatch.h @@ -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.
+ This program and the accompanying materials + are licensed and made available under the terms and conditions of the BS= D License + which accompanies this distribution. The full text of the license may b= e found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + + @par Revision Reference: + This protocol is from PI Version 1.5. + +**/ + +#ifndef _MM_USB_DISPATCH_H_ +#define _MM_USB_DISPATCH_H_ + +#include + +#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 reg= isters, 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 l= ocation 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 se= veral 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 calle= d when the USB- + related MMI specified by RegisterContext has occurred. On return, Dispat= chHandle + contains a unique handle which may be used later to unregister the funct= ion using UnRegister(). + The DispatchFunction will be called with Context set to the same value a= s 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_PROTOC= OL instance. + @param[in] DispatchFunction Function to register for handler when a U= SB-related MMI occurs. + @param[in] RegisterContext Pointer to the dispatch function's contex= t. + The caller fills this context in before c= alling + 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 tra= ck the function instance. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + registered and the MMI source has been en= abled. + @retval EFI_DEVICE_ERROR The driver was unable to enable the MMI s= ource. + @retval EFI_INVALID_PARAMETER RegisterContext is invalid. The USB MMI t= ype + 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_PROTOC= OL instance. + @param[in] DispatchHandle Handle of the service to remove. + + @retval EFI_SUCCESS The dispatch function has been successful= ly + unregistered and the MMI source has been = disabled + if there are no other registered child di= spatch + 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 sou= rce generator. +/// +struct _EFI_MM_USB_DISPATCH_PROTOCOL { + EFI_MM_USB_REGISTER Register; + EFI_MM_USB_UNREGISTER UnRegister; +}; + +extern EFI_GUID gEfiMmUsbDispatchProtocolGuid; + +#endif + diff --git a/MdePkg/MdePkg.dec b/MdePkg/MdePkg.dec index 425004f..4d2de8a 100644 --- a/MdePkg/MdePkg.dec +++ b/MdePkg/MdePkg.dec @@ -1171,6 +1171,73 @@ gEfiI2cBusConfigurationManagementProtocolGuid =3D { 0x55b71fb5, 0x17c6, = 0x410e, { 0xb5, 0xbd, 0x5f, 0xa2, 0xe3, 0xd4, 0x46, 0x6b }} =20 # + # Protocols defined in PI 1.5. + # + + ## Include/Protocol/MmEndOfDxe.h + gEfiMmEndOfDxeProtocolGuid =3D { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x3= 9, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }} + + ## Include/Protocol/MmIoTrapDispatch.h + gEfiMmIoTrapDispatchProtocolGuid =3D { 0x58dc368d, 0x7bfa, 0x4e77, {0xab= , 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }} + + ## Include/Protocol/MmPowerButtonDispatch.h + gEfiMmPowerButtonDispatchProtocolGuid =3D { 0x1b1183fa, 0x1823, 0x46a7, = {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }} + + ## Include/Protocol/MmStandbyButtonDispatch.h + gEfiMmStandbyButtonDispatchProtocolGuid =3D { 0x7300c4a1, 0x43f2, 0x4017= , {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }} + + ## Include/Protocol/MmGpiDispatch.h + gEfiMmGpiDispatchProtocolGuid =3D { 0x25566b03, 0xb577, 0x4cbf, {0x95, 0= x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }} + + ## Include/Protocol/MmUsbDispatch.h + gEfiMmUsbDispatchProtocolGuid =3D { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0= xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }} + + ## Include/Protocol/MmPeriodicTimerDispatch.h + gEfiMmPeriodicTimerDispatchProtocolGuid =3D { 0x4cec368e, 0x8e8e, 0x4d71= , {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }} + + ## Include/Protocol/MmSxDispatch.h + gEfiMmSxDispatchProtocolGuid =3D { 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0= xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }} + + ## Include/Protocol/MmSwDispatch.h + gEfiMmSwDispatchProtocolGuid =3D { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0= xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }} + + ## Include/Protocol/MmPciRootBridgeIo.h + gEfiMmPciRootBridgeIoProtocolGuid =3D { 0x8bc1714d, 0xffcb, 0x41c3, { 0x= 89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }} + + ## Include/Protocol/MmCpu.h + gEfiMmCpuProtocolGuid =3D { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b,= 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }} + + ## Include/Protocol/MmStatusCode.h + gEfiMmStatusCodeProtocolGuid =3D { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6,= 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}} + + ## Include/Protocol/DxeMmReadyToLock.h + gEfiDxeMmReadyToLockProtocolGuid =3D { 0x60ff8964, 0xe906, 0x41d0, { 0xa= f, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }} + + ## Include/Protocol/MmConfiguration.h + gEfiMmConfigurationProtocolGuid=3D { 0x26eeb3de, 0xb689, 0x492e, { 0x80,= 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }} + + ## Include/Protocol/MmReadyToLock.h + gEfiMmReadyToLockProtocolGuid =3D { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82,= 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }} + + ## Include/Protocol/MmControl.h + gEfiMmControlProtocolGuid =3D { 0x843dc720, 0xab1e, 0x42cb, { 0x93, = 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}} + + ## Include/Protocol/MmAccess.h + gEfiMmAccessProtocolGuid =3D { 0xc2702b74, 0x800c, 0x4131, { 0x87, = 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }} + + ## Include/Protocol/MmBase.h + gEfiMmBaseProtocolGuid =3D { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, = 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }} + + ## Include/Protocol/MmCpuIo.h + gEfiMmCpuIoProtocolGuid =3D { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95,= 0x5d, 0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }} + + ## Include/Protocol/MmReportStatusCodeHandler.h + gEfiMmRscHandlerProtocolGuid =3D { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3,= 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }} + + ## Include/Protocol/MmCommunication.h + gEfiMmCommunicationProtocolGuid =3D { 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9= d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }} + + # # Protocols defined in UEFI2.1/UEFI2.0/EFI1.1 # =20 --=20 2.7.0.windows.1 _______________________________________________ edk2-devel mailing list edk2-devel@lists.01.org https://lists.01.org/mailman/listinfo/edk2-devel