tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmBase/SmmBase.h

798 lines
24 KiB
C
Raw Normal View History

Add in the 1st version of ECP. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2832 6f19259b-4bc3-4df7-8a09-765794883524
2007-06-28 09:00:39 +02:00
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
SmmBase.h
Abstract:
This file defines SMM Base abstraction protocol defined by the SMM Architecture
Specification. This is the base level of compatiblity for SMM drivers.
--*/
#ifndef _SMM_BASE_H_
#define _SMM_BASE_H_
#include EFI_PROTOCOL_DEFINITION (DevicePath)
#define EFI_SMM_BASE_PROTOCOL_GUID \
{ \
0x1390954D, 0xda95, 0x4227, 0x93, 0x28, 0x72, 0x82, 0xc2, 0x17, 0xda, 0xa8 \
}
#define EFI_SMM_CPU_IO_GUID \
{ \
0x5f439a0b, 0x45d8, 0x4682, 0xa4, 0xf4, 0xf0, 0x57, 0x6b, 0x51, 0x34, 0x41 \
}
#define SMM_COMMUNICATE_HEADER_GUID \
{ \
0xF328E36C, 0x23B6, 0x4a95, 0x85, 0x4B, 0x32, 0xE1, 0x95, 0x34, 0xCD, 0x75 \
}
//
// SMM Base specification constant and types
//
#define SMM_SMST_SIGNATURE EFI_SIGNATURE_32 ('S', 'M', 'S', 'T')
#define EFI_SMM_SYSTEM_TABLE_REVISION (0 << 16) | (0x09)
EFI_FORWARD_DECLARATION (EFI_SMM_BASE_PROTOCOL);
EFI_FORWARD_DECLARATION (EFI_SMM_CPU_IO_INTERFACE);
EFI_FORWARD_DECLARATION (EFI_SMM_CPU_SAVE_STATE);
EFI_FORWARD_DECLARATION (EFI_SMM_OPTIONAL_FP_SAVE_STATE);
EFI_FORWARD_DECLARATION (EFI_SMM_SYSTEM_TABLE);
//
// *******************************************************
// EFI_SMM_IO_WIDTH
// *******************************************************
//
typedef enum {
SMM_IO_UINT8 = 0,
SMM_IO_UINT16 = 1,
SMM_IO_UINT32 = 2,
SMM_IO_UINT64 = 3
} EFI_SMM_IO_WIDTH;
//
// *******************************************************
// EFI_SMM_IO_ACCESS
// *******************************************************
//
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CPU_IO) (
IN EFI_SMM_CPU_IO_INTERFACE * This,
IN EFI_SMM_IO_WIDTH Width,
IN UINT64 Address,
IN UINTN Count,
IN OUT VOID *Buffer
);
typedef struct {
EFI_SMM_CPU_IO Read;
EFI_SMM_CPU_IO Write;
} EFI_SMM_IO_ACCESS;
typedef struct _EFI_SMM_CPU_IO_INTERFACE {
EFI_SMM_IO_ACCESS Mem;
EFI_SMM_IO_ACCESS Io;
} EFI_SMM_CPU_IO_INTERFACE;
typedef
EFI_STATUS
(EFIAPI *EFI_SMMCORE_ALLOCATE_POOL) (
IN EFI_MEMORY_TYPE PoolType,
IN UINTN Size,
OUT VOID **Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMMCORE_FREE_POOL) (
IN VOID *Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMMCORE_ALLOCATE_PAGES) (
IN EFI_ALLOCATE_TYPE Type,
IN EFI_MEMORY_TYPE MemoryType,
IN UINTN NumberOfPages,
OUT EFI_PHYSICAL_ADDRESS * Memory
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMMCORE_FREE_PAGES) (
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NumberOfPages
);
typedef
VOID
(EFIAPI *EFI_AP_PROCEDURE) (
IN VOID *Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STARTUP_THIS_AP) (
IN EFI_AP_PROCEDURE Procedure,
IN UINTN CpuNumber,
IN OUT VOID *ProcArguments OPTIONAL
);
typedef struct _EFI_SMM_CPU_SAVE_STATE {
UINT8 Reserved1[248];
UINT32 SMBASE;
UINT32 SMMRevId;
UINT16 IORestart;
UINT16 AutoHALTRestart;
UINT8 Reserved2[164];
UINT32 ES;
UINT32 CS;
UINT32 SS;
UINT32 DS;
UINT32 FS;
UINT32 GS;
UINT32 LDTBase;
UINT32 TR;
UINT32 DR7;
UINT32 DR6;
UINT32 EAX;
UINT32 ECX;
UINT32 EDX;
UINT32 EBX;
UINT32 ESP;
UINT32 EBP;
UINT32 ESI;
UINT32 EDI;
UINT32 EIP;
UINT32 EFLAGS;
UINT32 CR3;
UINT32 CR0;
} EFI_SMM_CPU_SAVE_STATE;
typedef struct {
UINT8 Reserved19[760]; // FC00
UINT32 SMBASE; // FEF8
UINT32 REVID; // FEFC
UINT16 HALT_RESTART; // FF00
UINT16 IO_RESTART; // FF02
UINT32 Reserved17[22]; // FF58, 54, 50, 4c, 48, 44, 40, 3c, 38, 34, 30, 2c, 28, 24, 20, 1c, 18, 14, 10, 0c, 08, 04
UINT32 EAX; // FF5C
UINT32 Reserved16; // FF60
UINT32 ECX; // FF64
UINT32 Reserved15; // FF68
UINT32 EDX; // FF6C
UINT32 Reserved14; // FF70
UINT32 EBX; // FF74
UINT32 Reserved13; // FF78
UINT32 ESP; // FF7C
UINT32 Reserved12; // FF80
UINT32 EBP; // FF84
UINT32 Reserved11; // FF88
UINT32 ESI; // FF8C
UINT32 Reserved9; // FF90
UINT32 EDI; // FF94
UINT32 Reserved8; // FF98
UINT32 IO_MEM_ADDR; // FF9C
UINT32 Reserved7; // FFA0
UINT32 IO_MISC; // FFA4
UINT32 ES_SEL; // FFA8
UINT32 CS_SEL; // FFAC
UINT32 SS_SEL; // FFB0
UINT32 DS_SEL; // FFB4
UINT32 FS_SEL; // FFB8
UINT32 GS_SEL; // FFBC
UINT32 LDTR_SEL; // FFC0
UINT32 TR_SEL; // FFC4
UINT32 DR7; // FFC8
UINT32 Reserved6; // FFCC
UINT32 DR6; // FFD0
UINT32 Reserved5; // FFD4
UINT32 EIP; // FFD8
UINT32 Reserved4; // FFDC
UINT32 EFER; // FFE0
UINT32 Reserved3; // FFE4
UINT32 EFLAGS; // FFE8
UINT32 Reserved2; // FFEC
UINT32 CR3; // FFF0
UINT32 Reserved1; // FFF4
UINT32 CR0; // FFF8
UINT32 Reserved0; // FFFC
} EFI_SMM_CPU_CT_SAVE_STATE;
typedef struct {
UINT8 Reserved26[464]; // FC00 - FDCF
UINT32 GdtrUpperBase; // FDD0
UINT32 LdtrUpperBase; // FDD4
UINT32 IdtrUpperBase; // FDD8
UINT32 Reserved25; // FDDC - FDDF
UINT64 IoRdi; // FDE0
UINT64 IoRip; // FDE8
UINT64 IoRcx; // FDF0
UINT64 IoRsi; // FDF8
UINT8 Reserved24[64]; // FE00 - FE3F
UINT64 Cr4; // FE40
UINT8 Reserved23[68]; // FE48 - FE8B
UINT32 GdtrBase; // FE8C
UINT32 Reserved22; // FE90
UINT32 IdtrBase; // FE94
UINT32 Reserved21; // FE98
UINT32 LdtrBase; // FE9C
UINT32 Reserved20; // FEA0
UINT8 Reserved19[84]; // FEA4 - FEF7
UINT32 Smbase; // FEF8
UINT32 RevId; // FEFC
UINT16 IoRestart; // FF00
UINT16 HaltRestart; // FF02
UINT8 Reserved18[24]; // FF04 - FF1B
UINT32 R15; // FF1C
UINT32 Reserved17; // FE20
UINT32 R14; // FF24
UINT32 Reserved16; // FE28
UINT32 R13; // FF2C
UINT32 Reserved15; // FE30
UINT32 R12; // FF34
UINT32 Reserved14; // FE38
UINT32 R11; // FF3C
UINT32 Reserved13; // FE40
UINT32 R10; // FF44
UINT32 Reserved12; // FE48
UINT32 R9; // FF4C
UINT32 Reserved11; // FE50
UINT32 R8; // FF54
UINT32 Reserved10; // FE58
UINT32 Rax; // FF5C
UINT32 Reserved9; // FE60
UINT32 Rcx; // FF64
UINT32 Reserved8; // FE68
UINT32 Rdx; // FF6C
UINT32 Reserved7; // FE70
UINT32 Rbx; // FF74
UINT32 Reserved6; // FE78
UINT32 Rsp; // FF7C
UINT32 Reserved5; // FE80
UINT32 Rbp; // FF84
UINT32 Reserved4; // FE88
UINT32 Rsi; // FF8C
UINT32 Reserved3; // FE90
UINT32 Rdi; // FF94
UINT32 Reserved2; // FE98
UINT32 IoMemAddr; // FF9C
UINT32 Reserved1; // FEA0
UINT32 IoMiscInfo; // FFA4
UINT32 EsSel; // FFA8
UINT32 CsSel; // FFAC
UINT32 SsSel; // FFB0
UINT32 DsSel; // FFB4
UINT32 FsSel; // FFB8
UINT32 GsSel; // FFBC
UINT32 LdtrSel; // FFC0
UINT32 TrSel; // FFC4
UINT64 Dr7; // FFC8
UINT64 Dr6; // FFD0
UINT32 Rip; // FFD8
UINT32 Reserved0; // FFDC
UINT64 Efr; // FFE0
UINT64 RFlags; // FFE8
UINT64 Cr3; // FFF0
UINT64 Cr0; // FFF8
} EFI_SMM_CPU_MEROM_SAVE_STATE;
typedef struct {
UINT8 Reserved14[0x228]; // FC00-FE28
UINT32 IO_EIP; // FE28
UINT8 Reserved13[0x14]; // FE2C-FE40
UINT32 CR4; // FE40
UINT8 Reserved12[0x48]; // FE44-FE8C
UINT32 GDT_BASE; // FE8C
UINT8 Reserved11[0xC]; // FE90-FE9C
UINT32 LDT_BASE; // FE9C
UINT8 Reserved10[0x58]; // FEA0-FEF8
UINT32 SMBASE;
UINT32 REVID;
UINT16 IO_RESTART;
UINT16 HALT_RESTART;
UINT8 Reserved9[0xA4];
UINT16 ES;
UINT16 Reserved8;
UINT16 CS;
UINT16 Reserved7;
UINT16 SS;
UINT16 Reserved6;
UINT16 DS;
UINT16 Reserved5;
UINT16 FS;
UINT16 Reserved4;
UINT16 GS;
UINT16 Reserved3;
UINT32 Reserved2;
UINT16 TR;
UINT16 Reserved1;
UINT32 DR7;
UINT32 DR6;
UINT32 EAX;
UINT32 ECX;
UINT32 EDX;
UINT32 EBX;
UINT32 ESP;
UINT32 EBP;
UINT32 ESI;
UINT32 EDI;
UINT32 EIP;
UINT32 EFLAGS;
UINT32 CR3;
UINT32 CR0;
} EFI_SMM_CPU_CT_NOT_ENABLED_SAVE_STATE;
typedef struct _EFI_SMM_OPTIONAL_FP_SAVE_STATE {
UINT16 Fcw;
UINT16 Fsw;
UINT16 Ftw;
UINT16 Opcode;
UINT32 Eip;
UINT16 Cs;
UINT16 Rsvd1;
UINT32 DataOffset;
UINT16 Ds;
UINT8 Rsvd2[10];
UINT8 St0Mm0[10], Rsvd3[6];
UINT8 St0Mm1[10], Rsvd4[6];
UINT8 St0Mm2[10], Rsvd5[6];
UINT8 St0Mm3[10], Rsvd6[6];
UINT8 St0Mm4[10], Rsvd7[6];
UINT8 St0Mm5[10], Rsvd8[6];
UINT8 St0Mm6[10], Rsvd9[6];
UINT8 St0Mm7[10], Rsvd10[6];
UINT8 Rsvd11[22 * 16];
} EFI_SMM_OPTIONAL_FP_SAVE_STATE;
typedef struct _EFI_SMM_OPTIONAL_FP_SAVE_STATE32 {
UINT16 Fcw;
UINT16 Fsw;
UINT16 Ftw;
UINT16 Opcode;
UINT32 Eip;
UINT16 Cs;
UINT16 Rsvd1;
UINT32 DataOffset;
UINT16 Ds;
UINT8 Reserved2[10];
UINT8 St0Mm0[10], Rsvd3[6];
UINT8 St1Mm1[10], Rsvd4[6];
UINT8 St2Mm2[10], Rsvd5[6];
UINT8 St3Mm3[10], Rsvd6[6];
UINT8 St4Mm4[10], Rsvd7[6];
UINT8 St5Mm5[10], Rsvd8[6];
UINT8 St6Mm6[10], Rsvd9[6];
UINT8 St7Mm7[10], Rsvd10[6];
UINT8 Xmm0[16];
UINT8 Xmm1[16];
UINT8 Xmm2[16];
UINT8 Xmm3[16];
UINT8 Xmm4[16];
UINT8 Xmm5[16];
UINT8 Xmm6[16];
UINT8 Xmm7[16];
UINT8 Rsvd11[14 * 16];
} EFI_SMM_OPTIONAL_FP_SAVE_STATE32;
typedef struct _EFI_SMM_OPTIONAL_FP_SAVE_STATE64 {
UINT16 Fcw;
UINT16 Fsw;
UINT16 Ftw;
UINT16 Opcode;
UINT64 Rip;
UINT64 DataOffset;
UINT8 Rsvd1[8];
UINT8 St0Mm0[10], Rsvd2[6];
UINT8 St1Mm1[10], Rsvd3[6];
UINT8 St2Mm2[10], Rsvd4[6];
UINT8 St3Mm3[10], Rsvd5[6];
UINT8 St4Mm4[10], Rsvd6[6];
UINT8 St5Mm5[10], Rsvd7[6];
UINT8 St6Mm6[10], Rsvd8[6];
UINT8 St7Mm7[10], Rsvd9[6];
UINT8 Xmm0[16];
UINT8 Xmm1[16];
UINT8 Xmm2[16];
UINT8 Xmm3[16];
UINT8 Xmm4[16];
UINT8 Xmm5[16];
UINT8 Xmm6[16];
UINT8 Xmm7[16];
UINT8 Xmm8[16];
UINT8 Xmm9[16];
UINT8 Xmm10[16];
UINT8 Xmm11[16];
UINT8 Xmm12[16];
UINT8 Xmm13[16];
UINT8 Xmm14[16];
UINT8 Xmm15[16];
UINT8 Rsvd10[6 * 16];
} EFI_SMM_OPTIONAL_FP_SAVE_STATE64;
struct _EFI_SMM_SYSTEM_TABLE;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INSTALL_CONFIGURATION_TABLE) (
IN EFI_SMM_SYSTEM_TABLE * SystemTable,
IN EFI_GUID * Guid,
IN VOID *Table,
IN UINTN TableSize
)
/*++
Routine Description:
The SmmInstallConfigurationTable() function is used to maintain the list
of configuration tables that are stored in the System Management System
Table. The list is stored as an array of (GUID, Pointer) pairs. The list
must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
Arguments:
SystemTable - A pointer to the SMM System Table.
Guid - A pointer to the GUID for the entry to add, update, or remove.
Table - A pointer to the buffer of the table to add.
TableSize - The size of the table to install.
Returns:
EFI_SUCCESS - The (Guid, Table) pair was added, updated, or removed.
EFI_INVALID_PARAMETER - Guid is not valid.
EFI_NOT_FOUND - An attempt was made to delete a non-existent entry.
EFI_OUT_OF_RESOURCES - There is not enough memory available to complete the operation.
--*/
;
//
// System Management System Table (SMST)
//
typedef struct _EFI_SMM_SYSTEM_TABLE {
EFI_TABLE_HEADER Hdr;
CHAR16 *SmmFirmwareVendor;
UINT32 SmmFirmwareRevision;
EFI_SMM_INSTALL_CONFIGURATION_TABLE SmmInstallConfigurationTable;
//
// I/O Services
//
EFI_GUID EfiSmmCpuIoGuid;
EFI_SMM_CPU_IO_INTERFACE SmmIo;
//
// Runtime memory service
//
EFI_SMMCORE_ALLOCATE_POOL SmmAllocatePool;
EFI_SMMCORE_FREE_POOL SmmFreePool;
EFI_SMMCORE_ALLOCATE_PAGES SmmAllocatePages;
EFI_SMMCORE_FREE_PAGES SmmFreePages;
//
// MP service
//
EFI_SMM_STARTUP_THIS_AP SmmStartupThisAp;
//
// CPU information records
//
UINTN CurrentlyExecutingCpu;
UINTN NumberOfCpus;
EFI_SMM_CPU_SAVE_STATE *CpuSaveState;
EFI_SMM_OPTIONAL_FP_SAVE_STATE *CpuOptionalFloatingPointState;
//
// Extensibility table
//
UINTN NumberOfTableEntries;
EFI_CONFIGURATION_TABLE *SmmConfigurationTable;
} EFI_SMM_SYSTEM_TABLE;
//
// SMM Handler Definition
//
#define EFI_HANDLER_SUCCESS 0x0000
#define EFI_HANDLER_CRITICAL_EXIT 0x0001
#define EFI_HANDLER_SOURCE_QUIESCED 0x0002
#define EFI_HANDLER_SOURCE_PENDING 0x0003
//
// Structure of Communicate Buffer
//
typedef struct {
EFI_GUID HeaderGuid;
UINTN MessageLength;
UINT8 Data[1];
} EFI_SMM_COMMUNICATE_HEADER;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT) (
IN EFI_HANDLE SmmImageHandle,
IN OUT VOID *CommunicationBuffer OPTIONAL,
IN OUT UINTN *SourceSize OPTIONAL
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CALLBACK_ENTRY_POINT) (
IN EFI_HANDLE SmmImageHandle,
IN OUT VOID *CommunicationBuffer OPTIONAL,
IN OUT UINTN *SourceSize OPTIONAL
);
typedef struct {
EFI_HANDLE SmmHandler;
EFI_DEVICE_PATH_PROTOCOL *HandlerDevicePath;
} EFI_HANDLER_DESCRIPTOR;
//
// SMM Base Protocol Definition
//
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_REGISTER_HANDLER) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN EFI_DEVICE_PATH_PROTOCOL * FilePath,
IN VOID *SourceBuffer OPTIONAL,
IN UINTN SourceSize,
OUT EFI_HANDLE * ImageHandle,
IN BOOLEAN LegacyIA32Binary OPTIONAL
)
/*++
Routine Description:
Register a given driver into SMRAM. This is the equivalent of performing
the LoadImage/StartImage into System Management Mode.
Arguments:
This - Protocol instance pointer.
SourceBuffer - Optional source buffer in case of the image file
being in memory.
SourceSize - Size of the source image file, if in memory.
ImageHandle - Pointer to the handle that reflects the driver
loaded into SMM.
LegacyIA32Binary - The binary image to load is legacy 16 bit code.
Returns:
EFI_SUCCESS - The operation was successful.
EFI_OUT_OF_RESOURCES - There were no additional SMRAM resources to load the handler
EFI_UNSUPPORTED - This platform does not support 16-bit handlers.
EFI_UNSUPPORTED - In runtime.
EFI_INVALID_PARAMETER - The handlers was not the correct image type
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_UNREGISTER_HANDLER) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN EFI_HANDLE ImageHandle
)
/*++
Routine Description:
Remove a given driver SMRAM. This is the equivalent of performing
the UnloadImage System Management Mode.
Arguments:
This - Protocol instance pointer.
ImageHandle - Pointer to the handle that reflects the driver
loaded into SMM.
Returns:
EFI_SUCCESS - The operation was successful
EFI_INVALID_PARAMETER - The handler did not exist
EFI_UNSUPPORTED - In runtime.
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_COMMUNICATE) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN EFI_HANDLE ImageHandle,
IN OUT VOID *CommunicationBuffer,
IN OUT UINTN *SourceSize
)
/*++
Routine Description:
The SMM Inter-module Communicate Service Communicate() function
provides a services to send/received messages from a registered
EFI service. The BASE protocol driver is responsible for doing
any of the copies such that the data lives in boot-service accessible RAM.
Arguments:
This - Protocol instance pointer.
ImageHandle - Pointer to the handle that reflects the driver
loaded into SMM.
CommunicationBuffer - Pointer to the buffer to convey into SMRAM.
SourceSize - Size of the contents of buffer..
Returns:
EFI_SUCCESS - The message was successfully posted
EFI_INVALID_PARAMETER - The buffer was NULL
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CALLBACK_SERVICE) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN EFI_HANDLE SmmImageHandle,
IN EFI_SMM_CALLBACK_ENTRY_POINT CallbackAddress,
IN BOOLEAN MakeLast OPTIONAL,
IN BOOLEAN FloatingPointSave OPTIONAL
)
/*++
Routine Description:
Register a callback to execute within SMM.
This allows receipt of messages created with the Boot Service COMMUNICATE.
Arguments:
This - Protocol instance pointer.
CallbackAddress - Address of the callback service
MakeFirst - If present, will stipulate that the handler is posted
to be the first module executed in the dispatch table.
MakeLast - If present, will stipulate that the handler is posted
to be last executed in the dispatch table.
FloatingPointSave - This is an optional parameter which informs the
EFI_SMM_ACCESS_PROTOCOL Driver core if it needs to save
the floating point register state. If any of the handlers
require this, then the state will be saved for all of the handlers.
Returns:
EFI_SUCCESS - The operation was successful
EFI_OUT_OF_RESOURCES - Not enough space in the dispatch queue
EFI_UNSUPPORTED - In runtime.
EFI_UNSUPPORTED - Not in SMM.
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ALLOCATE_POOL) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN EFI_MEMORY_TYPE PoolType,
IN UINTN Size,
OUT VOID **Buffer
)
/*++
Routine Description:
The SmmAllocatePool() function allocates a memory region of Size bytes from memory of
type PoolType and returns the address of the allocated memory in the location referenced
by Buffer. This function allocates pages from EFI SMRAM Memory as needed to grow the
requested pool type. All allocations are eight-byte aligned.
Arguments:
This - Protocol instance pointer.
PoolType - The type of pool to allocate.
The only supported type is EfiRuntimeServicesData;
the interface will internally map this runtime request to SMRAM.
Size - The number of bytes to allocate from the pool.
Buffer - A pointer to a pointer to the allocated buffer if the call
succeeds; undefined otherwise.
Returns:
EFI_SUCCESS - The requested number of bytes was allocated.
EFI_OUT_OF_RESOURCES - The pool requested could not be allocated.
EFI_INVALID_PARAMETER - PoolType was invalid.
EFI_UNSUPPORTED - In runtime.
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_FREE_POOL) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN VOID *Buffer
)
/*++
Routine Description:
The SmmFreePool() function returns the memory specified by Buffer to the system.
On return, the memory's type is EFI SMRAM Memory. The Buffer that is freed must
have been allocated by SmmAllocatePool().
Arguments:
This - Protocol instance pointer.
Buffer - Pointer to the buffer allocation.
Returns:
EFI_SUCCESS - The memory was returned to the system.
EFI_INVALID_PARAMETER - Buffer was invalid.
EFI_UNSUPPORTED - In runtime.
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INSIDE_OUT) (
IN EFI_SMM_BASE_PROTOCOL * This,
OUT BOOLEAN *InSmm
)
/*++
Routine Description:
This routine tells caller if execution context is SMM or not.
Arguments:
This - Protocol instance pointer.
Returns:
EFI_SUCCESS - The operation was successful
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GET_SMST_LOCATION) (
IN EFI_SMM_BASE_PROTOCOL * This,
IN OUT EFI_SMM_SYSTEM_TABLE **Smst
)
/*++
Routine Description:
The GetSmstLocation() function returns the locatin of the System Management
Service Table. The use of the API is such that a driver can discover the
location of the SMST in its entry point and then cache it in some driver
global variable so that the SMST can be invoked in subsequent callbacks.
Arguments:
This - Protocol instance pointer.
Smst - Pointer to the SMST.
Returns:
EFI_SUCCESS - The operation was successful
EFI_INVALID_PARAMETER - Smst was invalid.
EFI_UNSUPPORTED - Not in SMM.
--*/
;
typedef struct _EFI_SMM_BASE_PROTOCOL {
EFI_SMM_REGISTER_HANDLER Register;
EFI_SMM_UNREGISTER_HANDLER UnRegister;
EFI_SMM_COMMUNICATE Communicate;
EFI_SMM_CALLBACK_SERVICE RegisterCallback;
EFI_SMM_INSIDE_OUT InSmm;
EFI_SMM_ALLOCATE_POOL SmmAllocatePool;
EFI_SMM_FREE_POOL SmmFreePool;
EFI_SMM_GET_SMST_LOCATION GetSmstLocation;
} EFI_SMM_BASE_PROTOCOL;
extern EFI_GUID gEfiSmmBaseProtocolGuid;
extern EFI_GUID gEfiSmmCpuIoGuid;
extern EFI_GUID gEfiSmmCommunicateHeaderGuid;
#endif