Upstream
/
CloverBootloader
mirror of https://github.com/CloverHackyColor/CloverBootloader.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

additional includes 

Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
This commit is contained in:
Sergey Isakov 2019-09-03 16:36:55 +03:00
parent 081d1b5210
commit 8b8158cf56
65 changed files with 15351 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
IntelFrameworkModulePkg/Include/Guid/AcpiVariableCompatibility.h Normal file
View File

@ -0,0 +1,69 @@
/** @file
Definitions for data structures used in S3 resume.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions
of the BSD License which accompanies this distribution. The
full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _ACPI_VARIABLE_COMPATIBILITY_H_
#define _ACPI_VARIABLE_COMPATIBILITY_H_
#define EFI_ACPI_VARIABLE_COMPATIBILITY_GUID \
{ \
0xc020489e, 0x6db2, 0x4ef2, {0x9a, 0xa5, 0xca, 0x6, 0xfc, 0x11, 0xd3, 0x6a } \
}
#define ACPI_GLOBAL_VARIABLE L"AcpiGlobalVariable"
extern EFI_GUID gEfiAcpiVariableCompatiblityGuid;
typedef struct {
BOOLEAN APState;
BOOLEAN S3BootPath;
EFI_PHYSICAL_ADDRESS WakeUpBuffer;
EFI_PHYSICAL_ADDRESS GdtrProfile;
EFI_PHYSICAL_ADDRESS IdtrProfile;
EFI_PHYSICAL_ADDRESS CpuPrivateData;
EFI_PHYSICAL_ADDRESS StackAddress;
EFI_PHYSICAL_ADDRESS MicrocodePointerBuffer;
EFI_PHYSICAL_ADDRESS SmramBase;
EFI_PHYSICAL_ADDRESS SmmStartImageBase;
UINT32 SmmStartImageSize;
UINT32 NumberOfCpus;
} ACPI_CPU_DATA_COMPATIBILITY;
typedef struct {
//
// Acpi Related variables
//
EFI_PHYSICAL_ADDRESS AcpiReservedMemoryBase;
UINT32 AcpiReservedMemorySize;
EFI_PHYSICAL_ADDRESS S3ReservedLowMemoryBase;
EFI_PHYSICAL_ADDRESS AcpiBootScriptTable;
EFI_PHYSICAL_ADDRESS RuntimeScriptTableBase;
EFI_PHYSICAL_ADDRESS AcpiFacsTable;
UINT64 SystemMemoryLength;
ACPI_CPU_DATA_COMPATIBILITY AcpiCpuData;
//
// VGA OPROM to support Video Re-POST for Linux S3
//
EFI_PHYSICAL_ADDRESS VideoOpromAddress;
UINT32 VideoOpromSize;
//
// S3 Debug extension
//
EFI_PHYSICAL_ADDRESS S3DebugBufferAddress;
EFI_PHYSICAL_ADDRESS S3ResumeNvsEntryPoint;
} ACPI_VARIABLE_SET_COMPATIBILITY;
#endif

55
IntelFrameworkModulePkg/Include/Guid/BdsHii.h Normal file
View File

@ -0,0 +1,55 @@
/** @file
GUIDs used as HII FormSet and HII Package list GUID in BdsDxe driver.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __BDS_HII_GUIDS_H__
#define __BDS_HII_GUIDS_H__
#define FRONT_PAGE_FORMSET_GUID \
{ \
0x9e0c30bc, 0x3f06, 0x4ba6, {0x82, 0x88, 0x9, 0x17, 0x9b, 0x85, 0x5d, 0xbe} \
}
#define BOOT_MANAGER_FORMSET_GUID \
{ \
0x847bc3fe, 0xb974, 0x446d, {0x94, 0x49, 0x5a, 0xd5, 0x41, 0x2e, 0x99, 0x3b} \
}
#define DEVICE_MANAGER_FORMSET_GUID \
{ \
0x3ebfa8e6, 0x511d, 0x4b5b, {0xa9, 0x5f, 0xfb, 0x38, 0x26, 0xf, 0x1c, 0x27} \
}
#define DRIVER_HEALTH_FORMSET_GUID \
{ \
0xf76e0a70, 0xb5ed, 0x4c38, {0xac, 0x9a, 0xe5, 0xf5, 0x4b, 0xf1, 0x6e, 0x34} \
}
#define BOOT_MAINT_FORMSET_GUID \
{ \
0x642237c7, 0x35d4, 0x472d, {0x83, 0x65, 0x12, 0xe0, 0xcc, 0xf2, 0x7a, 0x22} \
}
#define FILE_EXPLORE_FORMSET_GUID \
{ \
0x1f2d63e1, 0xfebd, 0x4dc7, {0x9c, 0xc5, 0xba, 0x2b, 0x1c, 0xef, 0x9c, 0x5b} \
}
extern EFI_GUID gFrontPageFormSetGuid;
extern EFI_GUID gBootMaintFormSetGuid;
extern EFI_GUID gFileExploreFormSetGuid;
extern EFI_GUID gBootManagerFormSetGuid;
extern EFI_GUID gDeviceManagerFormSetGuid;
extern EFI_GUID gDriverHealthFormSetGuid;
#endif

25
IntelFrameworkModulePkg/Include/Guid/BdsLibHii.h Normal file
View File

@ -0,0 +1,25 @@
/** @file
GUID used as HII Package list GUID in GenericBdsLib module.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __BDS_LIB_HII_GUID_H__
#define __BDS_LIB_HII_GUID_H__
#define BDS_LIB_STRING_PACKAGE_GUID \
{ \
0x3b4d9b23, 0x95ac, 0x44f6, { 0x9f, 0xcd, 0xe, 0x95, 0x94, 0x58, 0x6c, 0x72 } \
}
extern EFI_GUID gBdsLibStringPackageGuid;
#endif

31
IntelFrameworkModulePkg/Include/Guid/BlockIoVendor.h Normal file
View File

@ -0,0 +1,31 @@
/** @file
Guid for unrecognized EDD 3.0 device.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __BLOCKIO_VENDOR_H__
#define __BLOCKIO_VENDOR_H__
//
// Guid is to specifiy the unrecognized EDD 3.0 device.
//
#define BLOCKIO_VENDOR_GUID \
{ 0xcf31fac5, 0xc24e, 0x11d2, {0x85, 0xf3, 0x0, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b} }
typedef struct {
VENDOR_DEVICE_PATH DevicePath;
UINT8 LegacyDriveLetter;
} BLOCKIO_VENDOR_DEVICE_PATH;
extern GUID gBlockIoVendorGuid;
#endif

23
IntelFrameworkModulePkg/Include/Guid/CapsuleDataFile.h Normal file
View File

@ -0,0 +1,23 @@
/** @file
GUID to specify which FFS file to store the updated capsule data.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __UPDATE_DATA_FILE_GUID_H__
#define __UPDATE_DATA_FILE_GUID_H__
#define EFI_UPDATE_DATA_FILE_GUID \
{ 0x283fa2ee, 0x532c, 0x484d, { 0x93, 0x83, 0x9f, 0x93, 0xb3, 0x6f, 0xb, 0x7e } }
extern GUID gEfiUpdateDataFileGuid;
#endif

61
IntelFrameworkModulePkg/Include/Guid/DataHubStatusCodeRecord.h Normal file
View File

@ -0,0 +1,61 @@
/** @file
GUID used to identify Data Hub records logged by Status Code Protocol.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __DATA_HUB_STATUS_CODE_RECORD_H__
#define __DATA_HUB_STATUS_CODE_RECORD_H__
///
/// The Global ID used to identify a structure of type DATA_HUB_STATUS_CODE_DATA_RECORD.
///
#define EFI_DATA_HUB_STATUS_CODE_RECORD_GUID \
{ \
0xd083e94c, 0x6560, 0x42e4, {0xb6, 0xd4, 0x2d, 0xf7, 0x5a, 0xdf, 0x6a, 0x2a } \
}
///
/// The Data Hub data record that is used to store all the parameters passed into
/// the ReportStatusCode() service of the EFI_STATUS_CODE_PROTOCOL.
///
typedef struct {
///
/// Status Code type to be reported.
///
EFI_STATUS_CODE_TYPE CodeType;
///
/// An operation, plus value information about the class and subclass, used to
/// classify the hardware and software entity.
///
EFI_STATUS_CODE_VALUE Value;
///
/// The enumeration of a hardware or software entity within
/// the system. Valid instance numbers start with 1.
///
UINT32 Instance;
///
/// Identify the caller.
///
EFI_GUID CallerId;
///
/// Additional status code data.
///
EFI_STATUS_CODE_DATA Data;
} DATA_HUB_STATUS_CODE_DATA_RECORD;
extern EFI_GUID gEfiDataHubStatusCodeRecordGuid;
#endif

31
IntelFrameworkModulePkg/Include/Guid/HdBootVariable.h Normal file
View File

@ -0,0 +1,31 @@
/** @file
GUID used as EFI Variable for the device path of Boot file on HardDevice.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __HD_DEVICE_PATH_VARIABLE_GUID_H__
#define __HD_DEVICE_PATH_VARIABLE_GUID_H__
///
/// This GUID is used for an EFI Variable that stores the front device pathes
/// for a partial device path that starts with the HD node.
///
#define HD_BOOT_DEVICE_PATH_VARIABLE_GUID \
{ \
0xfab7e9e1, 0x39dd, 0x4f2b, { 0x84, 0x8, 0xe2, 0xe, 0x90, 0x6c, 0xb6, 0xde } \
}
#define HD_BOOT_DEVICE_PATH_VARIABLE_NAME L"HDDP"
extern EFI_GUID gHdBootDevicePathVariablGuid;
#endif

27
IntelFrameworkModulePkg/Include/Guid/IntelFrameworkModulePkgTokenSpace.h Normal file
View File

@ -0,0 +1,27 @@
/** @file
GUID for IntelFrameworkModulePkg PCD Token Space
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _INTEL_FRAMEWOKR_MODULEPKG_TOKEN_SPACE_GUID_H_
#define _INTEL_FRAMEWOKR_MODULEPKG_TOKEN_SPACE_GUID_H_
///
/// The Global ID for the IntelFrameworkModulePkg PCD Token Space .
///
#define INTEL_FRAMEWORK_MODULEPKG_TOKEN_SPACE_GUID \
{ \
0xD3705011, 0xBC19, 0x4af7, { 0xBE, 0x16, 0xF6, 0x80, 0x30, 0x37, 0x8C, 0x15 } \
}
extern EFI_GUID gEfiIntelFrameworkModulePkgTokenSpaceGuid;
#endif

31
IntelFrameworkModulePkg/Include/Guid/LastEnumLang.h Normal file
View File

@ -0,0 +1,31 @@
/** @file
GUID used as EFI variable to store platform language at last time enumeration.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __LAST_ENUM_LANGUAGE_GUID_H__
#define __LAST_ENUM_LANGUAGE_GUID_H__
///
/// This GUID is used for Set/Get platform language into/from variable at last time enumeration
/// to ensure the enumeration will only execute once.
///
#define LAST_ENUM_LANGUAGE_GUID \
{ \
0xe8c545b, 0xa2ee, 0x470d, { 0x8e, 0x26, 0xbd, 0xa1, 0xa1, 0x3c, 0xa, 0xa3 } \
}
#define LAST_ENUM_LANGUAGE_VARIABLE_NAME L"LastEnumLang"
extern EFI_GUID gLastEnumLangGuid;
#endif

36
IntelFrameworkModulePkg/Include/Guid/LegacyBios.h Normal file
View File

@ -0,0 +1,36 @@
/** @file
Defines a Tag GUID used to mark a UEFI legacy BIOS thunk driver based
on legacy BIOS services and legacy option ROM. This Tag GUID must be installed on
the ImageHandle of any module that follows the EFI Driver Model and uses
the Int86() or FarCall() services of the Legacy Bios Protocol to produce
a standard UEFI I/O Protocol.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions
of the BSD License which accompanies this distribution. The
full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _LEGACY_BIOS_H_
#define _LEGACY_BIOS_H_
///
/// The Global ID for the Legacy BIOS GUID that must be installed onto the ImageHandle
/// of any module follows the EFI Driver Model and uses the Int86() or FarCall()
/// services of the Legacy BIOS Protocol to produce a standard UEFI I/O Protocol.
///
#define EFI_LEGACY_BIOS_GUID \
{ \
0x2e3044ac, 0x879f, 0x490f, {0x97, 0x60, 0xbb, 0xdf, 0xaf, 0x69, 0x5f, 0x50 } \
}
extern EFI_GUID gEfiLegacyBiosGuid;
#endif

45
IntelFrameworkModulePkg/Include/Guid/LegacyDevOrder.h Normal file
View File

@ -0,0 +1,45 @@
/** @file
Guid of a NV Variable which store the information about the
FD/HD/CD/NET/BEV order.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __LEGACY_DEV_ORDER_VARIABLE_GUID_H__
#define __LEGACY_DEV_ORDER_VARIABLE_GUID_H__
///
/// Name and Guid of a NV Variable which stores the information about the
/// FD/HD/CD/NET/BEV order
///
#define EFI_LEGACY_DEV_ORDER_VARIABLE_GUID \
{ \
0xa56074db, 0x65fe, 0x45f7, {0xbd, 0x21, 0x2d, 0x2b, 0xdd, 0x8e, 0x96, 0x52} \
}
typedef UINT8 BBS_TYPE;
#pragma pack(1)
typedef struct {
BBS_TYPE BbsType;
///
/// Length = sizeof (UINT16) + sizeof (Data)
///
UINT16 Length;
UINT16 Data[1];
} LEGACY_DEV_ORDER_ENTRY;
#pragma pack()
#define VAR_LEGACY_DEV_ORDER L"LegacyDevOrder"
extern EFI_GUID gEfiLegacyDevOrderVariableGuid;
#endif

28
IntelFrameworkModulePkg/Include/Guid/TianoDecompress.h Normal file
View File

@ -0,0 +1,28 @@
/** @file
Tiano Custom decompress Guid definition.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __TIANO_CUSTOM_DECOMPRESS_GUID_H__
#define __TIANO_CUSTOM_DECOMPRESS_GUID_H__
///
/// The Global ID used to identify a section of an FFS file of type
/// EFI_SECTION_GUID_DEFINED, whose contents have been compressed using
/// Tiano Custom compression.
///
#define TIANO_CUSTOM_DECOMPRESS_GUID \
{ 0xA31280AD, 0x481E, 0x41B6, { 0x95, 0xE8, 0x12, 0x7F, 0x4C, 0x98, 0x47, 0x79 } }
extern GUID gTianoCustomDecompressGuid;
#endif

1114
IntelFrameworkModulePkg/Include/Library/GenericBdsLib.h Normal file
View File

File diff suppressed because it is too large Load Diff

156
IntelFrameworkModulePkg/Include/Library/PlatformBdsLib.h Normal file
View File

@ -0,0 +1,156 @@
/** @file
Platform BDS library definition. A platform can implement
instances to support platform-specific behavior.
Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __PLATFORM_BDS_LIB_H_
#define __PLATFORM_BDS_LIB_H_
#include <Protocol/GenericMemoryTest.h>
#include <Library/GenericBdsLib.h>
/**
Perform the memory test base on the memory test intensive level,
and update the memory resource.
@param Level The memory test intensive level.
@retval EFI_STATUS Successfully test all the system memory, and update
the memory resource
**/
typedef
EFI_STATUS
(EFIAPI *BASEM_MEMORY_TEST)(
IN EXTENDMEM_COVERAGE_LEVEL Level
);
/**
This routine is called to see if there are any capsules we need to process.
If the boot mode is not UPDATE, then we do nothing. Otherwise, find the
capsule HOBS and produce firmware volumes for them via the DXE service.
Then call the dispatcher to dispatch drivers from them. Finally, check
the status of the updates.
This function should be called by BDS in case we need to do some
sort of processing even if there is no capsule to process. We
need to do this if an earlier update went away and we need to
clear the capsule variable so on the next reset PEI does not see it and
think there is a capsule available.
@param BootMode The current boot mode
@retval EFI_INVALID_PARAMETER The boot mode is not correct for an update.
@retval EFI_SUCCESS There is no error when processing a capsule.
**/
typedef
EFI_STATUS
(EFIAPI *PROCESS_CAPSULES)(
IN EFI_BOOT_MODE BootMode
);
/**
Platform Bds initialization. Includes the platform firmware vendor, revision
and so crc check.
**/
VOID
EFIAPI
PlatformBdsInit (
VOID
);
/**
The function will execute with as the platform policy, current policy
is driven by boot mode. IBV/OEM can customize this code for their specific
policy action.
@param DriverOptionList The header of the driver option link list
@param BootOptionList The header of the boot option link list
@param ProcessCapsules A pointer to ProcessCapsules()
@param BaseMemoryTest A pointer to BaseMemoryTest()
**/
VOID
EFIAPI
PlatformBdsPolicyBehavior (
IN LIST_ENTRY *DriverOptionList,
IN LIST_ENTRY *BootOptionList,
IN PROCESS_CAPSULES ProcessCapsules,
IN BASEM_MEMORY_TEST BaseMemoryTest
);
/**
Hook point for a user-provided function, for after a boot attempt fails.
@param Option A pointer to Boot Option that failed to boot.
@param Status The status returned from failed boot.
@param ExitData The exit data returned from failed boot.
@param ExitDataSize The exit data size returned from failed boot.
**/
VOID
EFIAPI
PlatformBdsBootFail (
IN BDS_COMMON_OPTION *Option,
IN EFI_STATUS Status,
IN CHAR16 *ExitData,
IN UINTN ExitDataSize
);
/**
Hook point after a boot attempt succeeds. We don't expect a boot option to
return, so the UEFI 2.0 specification defines that you will default to an
interactive mode and stop processing the BootOrder list in this case. This
is also a platform implementation, and can be customized by an IBV/OEM.
@param Option A pointer to the Boot Option that successfully booted.
**/
VOID
EFIAPI
PlatformBdsBootSuccess (
IN BDS_COMMON_OPTION *Option
);
/**
This function locks platform flash that is not allowed to be updated during normal boot path.
The flash layout is platform specific.
**/
VOID
EFIAPI
PlatformBdsLockNonUpdatableFlash (
VOID
);
/**
Lock the ConsoleIn device in system table. All key
presses will be ignored until the Password is typed in. The only way to
disable the password is to type it in to a ConIn device.
@param Password The password used to lock ConIn device.
@retval EFI_SUCCESS Lock the Console In Spliter virtual handle successfully.
@retval EFI_UNSUPPORTED Password not found.
**/
EFI_STATUS
EFIAPI
LockKeyboards (
IN CHAR16 *Password
);
#endif

25
IntelFrameworkModulePkg/Include/Protocol/ExitPmAuth.h Normal file
View File

@ -0,0 +1,25 @@
/** @file
Defines the ExitPmAuth protocol.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions
of the BSD License which accompanies this distribution. The
full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _EXIT_PM_AUTH_PROTOCOL_H_
#define _EXIT_PM_AUTH_PROTOCOL_H_
#define EXIT_PM_AUTH_PROTOCOL_GUID \
{ 0xd088a413, 0xa70, 0x4217, { 0xba, 0x55, 0x9a, 0x3c, 0xb6, 0x5c, 0x41, 0xb3 }}
extern EFI_GUID gExitPmAuthProtocolGuid;
#endif // #ifndef _EXIT_PM_AUTH_PROTOCOL_H_

304
IntelFrameworkModulePkg/Include/Protocol/IsaAcpi.h Normal file
View File

@ -0,0 +1,304 @@
/** @file
EFI ISA ACPI Protocol is used to enumerate and manage all the ISA controllers on
the platform's ISA Bus.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __ISA_ACPI_H_
#define __ISA_ACPI_H_
///
/// Global ID for the EFI ISA ACPI Protocol.
///
#define EFI_ISA_ACPI_PROTOCOL_GUID \
{ \
0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
}
///
/// Forward declaration fo the EFI ISA ACPI Protocol
///
typedef struct _EFI_ISA_ACPI_PROTOCOL EFI_ISA_ACPI_PROTOCOL;
///
/// ISA ACPI Protocol interrupt resource attributes.
///
#define EFI_ISA_ACPI_IRQ_TYPE_HIGH_TRUE_EDGE_SENSITIVE 0x01 ///< Edge triggered interrupt on a rising edge.
#define EFI_ISA_ACPI_IRQ_TYPE_LOW_TRUE_EDGE_SENSITIVE 0x02 ///< Edge triggered interrupt on a falling edge.
#define EFI_ISA_ACPI_IRQ_TYPE_HIGH_TRUE_LEVEL_SENSITIVE 0x04 ///< Level sensitive interrupt active high.
#define EFI_ISA_ACPI_IRQ_TYPE_LOW_TRUE_LEVEL_SENSITIVE 0x08 ///< Level sensitive interrupt active low.
///
/// ISA ACPI Protocol DMA resource attributes.
///
#define EFI_ISA_ACPI_DMA_SPEED_TYPE_MASK 0x03 ///< Bit mask of supported DMA speed attributes.
#define EFI_ISA_ACPI_DMA_SPEED_TYPE_COMPATIBILITY 0x00 ///< ISA controller supports compatibility mode DMA transfers.
#define EFI_ISA_ACPI_DMA_SPEED_TYPE_A 0x01 ///< ISA controller supports type A DMA transfers.
#define EFI_ISA_ACPI_DMA_SPEED_TYPE_B 0x02 ///< ISA controller supports type B DMA transfers.
#define EFI_ISA_ACPI_DMA_SPEED_TYPE_F 0x03 ///< ISA controller supports type F DMA transfers.
#define EFI_ISA_ACPI_DMA_COUNT_BY_BYTE 0x04 ///< ISA controller increments DMA address by bytes (8-bit).
#define EFI_ISA_ACPI_DMA_COUNT_BY_WORD 0x08 ///< ISA controller increments DMA address by words (16-bit).
#define EFI_ISA_ACPI_DMA_BUS_MASTER 0x10 ///< ISA controller is a DMA bus master.
#define EFI_ISA_ACPI_DMA_TRANSFER_TYPE_8_BIT 0x20 ///< ISA controller only supports 8-bit DMA transfers.
#define EFI_ISA_ACPI_DMA_TRANSFER_TYPE_8_BIT_AND_16_BIT 0x40 ///< ISA controller both 8-bit and 16-bit DMA transfers.
#define EFI_ISA_ACPI_DMA_TRANSFER_TYPE_16_BIT 0x80 ///< ISA controller only supports 16-bit DMA transfers.
///
/// ISA ACPI Protocol MMIO resource attributes
///
#define EFI_ISA_ACPI_MEMORY_WIDTH_MASK 0x03 ///< Bit mask of supported ISA memory width attributes.
#define EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT 0x00 ///< ISA MMIO region only supports 8-bit access.
#define EFI_ISA_ACPI_MEMORY_WIDTH_16_BIT 0x01 ///< ISA MMIO region only supports 16-bit access.
#define EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT_AND_16_BIT 0x02 ///< ISA MMIO region supports both 8-bit and 16-bit access.
#define EFI_ISA_ACPI_MEMORY_WRITEABLE 0x04 ///< ISA MMIO region supports write transactions.
#define EFI_ISA_ACPI_MEMORY_CACHEABLE 0x08 ///< ISA MMIO region supports being cached.
#define EFI_ISA_ACPI_MEMORY_SHADOWABLE 0x10 ///< ISA MMIO region may be shadowed.
#define EFI_ISA_ACPI_MEMORY_EXPANSION_ROM 0x20 ///< ISA MMIO region is an expansion ROM.
///
/// ISA ACPI Protocol I/O resource attributes
///
#define EFI_ISA_ACPI_IO_DECODE_10_BITS 0x01 ///< ISA controllers uses a 10-bit address decoder for I/O cycles.
#define EFI_ISA_ACPI_IO_DECODE_16_BITS 0x02 ///< ISA controllers uses a 16-bit address decoder for I/O cycles.
///
/// EFI ISA ACPI resource type
///
typedef enum {
EfiIsaAcpiResourceEndOfList, ///< Marks the end if a resource list.
EfiIsaAcpiResourceIo, ///< ISA I/O port resource range.
EfiIsaAcpiResourceMemory, ///< ISA MMIO resource range.
EfiIsaAcpiResourceDma, ///< ISA DMA resource.
EfiIsaAcpiResourceInterrupt ///< ISA interrupt resource.
} EFI_ISA_ACPI_RESOURCE_TYPE;
///
/// EFI ISA ACPI generic resource structure
///
typedef struct {
EFI_ISA_ACPI_RESOURCE_TYPE Type; ///< The type of resource (I/O, MMIO, DMA, Interrupt).
UINT32 Attribute; ///< Bit mask of attributes associated with this resource. See EFI_ISA_ACPI_xxx macros for valid combinations.
UINT32 StartRange; ///< The start of the resource range.
UINT32 EndRange; ///< The end of the resource range.
} EFI_ISA_ACPI_RESOURCE;
///
/// EFI ISA ACPI resource device identifier
///
typedef struct {
UINT32 HID; ///< The ACPI Hardware Identifier value associated with an ISA controller. Matchs ACPI DSDT contents.
UINT32 UID; ///< The ACPI Unique Identifier value associated with an ISA controller. Matches ACPI DSDT contents.
} EFI_ISA_ACPI_DEVICE_ID;
///
/// EFI ISA ACPI resource list
///
typedef struct {
EFI_ISA_ACPI_DEVICE_ID Device; ///< The ACPI HID/UID associated with an ISA controller.
EFI_ISA_ACPI_RESOURCE *ResourceItem; ///< A pointer to the list of resources associated with an ISA controller.
} EFI_ISA_ACPI_RESOURCE_LIST;
/**
Enumerates the ISA controllers on an ISA bus.
This service allows all the ISA controllers on an ISA bus to be enumerated. If
Device is a pointer to a NULL value, then the first ISA controller on the ISA
bus is returned in Device and EFI_SUCCESS is returned. If Device is a pointer
to a value that was returned on a prior call to DeviceEnumerate(), then the next
ISA controller on the ISA bus is returned in Device and EFI_SUCCESS is returned.
If Device is a pointer to the last ISA controller on the ISA bus, then
EFI_NOT_FOUND is returned.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[out] Device The pointer to an ISA controller named by ACPI HID/UID.
@retval EFI_SUCCESS The next ISA controller on the ISA bus was returned.
@retval EFI_NOT_FOUND No device found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_DEVICE_ENUMERATE)(
IN EFI_ISA_ACPI_PROTOCOL *This,
OUT EFI_ISA_ACPI_DEVICE_ID **Device
);
/**
Sets the power state of an ISA controller.
This services sets the power state of the ISA controller specified by Device to
the power state specified by OnOff. TRUE denotes on, FALSE denotes off.
If the power state is sucessfully set on the ISA Controller, then
EFI_SUCCESS is returned.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[in] Device The pointer to an ISA controller named by ACPI HID/UID.
@param[in] OnOff TRUE denotes on, FALSE denotes off.
@retval EFI_SUCCESS Successfully set the power state of the ISA controller.
@retval Other The ISA controller could not be placed in the requested power state.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_SET_DEVICE_POWER)(
IN EFI_ISA_ACPI_PROTOCOL *This,
IN EFI_ISA_ACPI_DEVICE_ID *Device,
IN BOOLEAN OnOff
);
/**
Retrieves the current set of resources associated with an ISA controller.
Retrieves the set of I/O, MMIO, DMA, and interrupt resources currently
assigned to the ISA controller specified by Device. These resources
are returned in ResourceList.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[in] Device The pointer to an ISA controller named by ACPI HID/UID.
@param[out] ResourceList The pointer to the current resource list for Device.
@retval EFI_SUCCESS Successfully retrieved the current resource list.
@retval EFI_NOT_FOUND The resource list could not be retrieved.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_GET_CUR_RESOURCE)(
IN EFI_ISA_ACPI_PROTOCOL *This,
IN EFI_ISA_ACPI_DEVICE_ID *Device,
OUT EFI_ISA_ACPI_RESOURCE_LIST **ResourceList
);
/**
Retrieves the set of possible resources that may be assigned to an ISA controller
with SetResource().
Retrieves the possible sets of I/O, MMIO, DMA, and interrupt resources for the
ISA controller specified by Device. The sets are returned in ResourceList.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[in] Device The pointer to an ISA controller named by ACPI HID/UID.
@param[out] ResourceList The pointer to the returned list of resource lists.
@retval EFI_UNSUPPORTED This service is not supported.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_GET_POS_RESOURCE)(
IN EFI_ISA_ACPI_PROTOCOL *This,
IN EFI_ISA_ACPI_DEVICE_ID *Device,
OUT EFI_ISA_ACPI_RESOURCE_LIST **ResourceList
);
/**
Assigns resources to an ISA controller.
Assigns the I/O, MMIO, DMA, and interrupt resources specified by ResourceList
to the ISA controller specified by Device. ResourceList must match a resource list returned by GetPosResource() for the same ISA controller.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[in] Device The pointer to an ISA controller named by ACPI HID/UID.
@param[in] ResourceList The pointer to a resources list that must be one of the
resource lists returned by GetPosResource() for the
ISA controller specified by Device.
@retval EFI_SUCCESS Successfully set resources on the ISA controller.
@retval Other The resources could not be set for the ISA controller.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_SET_RESOURCE)(
IN EFI_ISA_ACPI_PROTOCOL *This,
IN EFI_ISA_ACPI_DEVICE_ID *Device,
IN EFI_ISA_ACPI_RESOURCE_LIST *ResourceList
);
/**
Enables or disables an ISA controller.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[in] Device The pointer to the ISA controller to enable/disable.
@param[in] Enable TRUE to enable the ISA controller. FALSE to disable the
ISA controller.
@retval EFI_SUCCESS Successfully enabled/disabled the ISA controller.
@retval Other The ISA controller could not be placed in the requested state.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_ENABLE_DEVICE)(
IN EFI_ISA_ACPI_PROTOCOL *This,
IN EFI_ISA_ACPI_DEVICE_ID *Device,
IN BOOLEAN Enable
);
/**
Initializes an ISA controller, so that it can be used. This service must be called
before SetResource(), EnableDevice(), or SetPower() will behave as expected.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@param[in] Device The pointer to an ISA controller named by ACPI HID/UID.
@retval EFI_SUCCESS Successfully initialized an ISA controller.
@retval Other The ISA controller could not be initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_INIT_DEVICE)(
IN EFI_ISA_ACPI_PROTOCOL *This,
IN EFI_ISA_ACPI_DEVICE_ID *Device
);
/**
Initializes all the HW states required for the ISA controllers on the ISA bus
to be enumerated and managed by the rest of the services in this prorotol.
This service must be called before any of the other services in this
protocol will function as expected.
@param[in] This The pointer to the EFI_ISA_ACPI_PROTOCOL instance.
@retval EFI_SUCCESS Successfully initialized all required hardware states.
@retval Other The ISA interface could not be initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_ACPI_INTERFACE_INIT)(
IN EFI_ISA_ACPI_PROTOCOL *This
);
///
/// The EFI_ISA_ACPI_PROTOCOL provides the services to enumerate and manage
/// ISA controllers on an ISA bus. These services include the ability to initialize,
/// enable, disable, and manage the power state of ISA controllers. It also
/// includes services to query current resources, query possible resources,
/// and assign resources to an ISA controller.
///
struct _EFI_ISA_ACPI_PROTOCOL {
EFI_ISA_ACPI_DEVICE_ENUMERATE DeviceEnumerate;
EFI_ISA_ACPI_SET_DEVICE_POWER SetPower;
EFI_ISA_ACPI_GET_CUR_RESOURCE GetCurResource;
EFI_ISA_ACPI_GET_POS_RESOURCE GetPosResource;
EFI_ISA_ACPI_SET_RESOURCE SetResource;
EFI_ISA_ACPI_ENABLE_DEVICE EnableDevice;
EFI_ISA_ACPI_INIT_DEVICE InitDevice;
EFI_ISA_ACPI_INTERFACE_INIT InterfaceInit;
};
extern EFI_GUID gEfiIsaAcpiProtocolGuid;
#endif

362
IntelFrameworkModulePkg/Include/Protocol/IsaIo.h Normal file
View File

@ -0,0 +1,362 @@
/** @file
ISA I/O Protocol is used by ISA device drivers to perform I/O, MMIO and DMA
operations on the ISA controllers they manage.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _EFI_ISA_IO_H_
#define _EFI_ISA_IO_H_
#include <Protocol/IsaAcpi.h>
///
/// Global ID for the EFI_ISA_IO_PROTOCOL
///
#define EFI_ISA_IO_PROTOCOL_GUID \
{ \
0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
}
///
/// Forward declaration for the EFI_ISA_IO_PROTOCOL.
///
typedef struct _EFI_ISA_IO_PROTOCOL EFI_ISA_IO_PROTOCOL;
///
/// Width of EFI_ISA_IO_PROTOCOL I/O Port and MMIO operations.
///
typedef enum {
EfiIsaIoWidthUint8 = 0, ///< 8-bit operation.
EfiIsaIoWidthUint16, ///< 16-bit operation.
EfiIsaIoWidthUint32, ///< 32-bit operation
EfiIsaIoWidthReserved,
EfiIsaIoWidthFifoUint8, ///< 8-bit FIFO operation.
EfiIsaIoWidthFifoUint16, ///< 16-bit FIFO operation.
EfiIsaIoWidthFifoUint32, ///< 32-bit FIFO operation.
EfiIsaIoWidthFifoReserved,
EfiIsaIoWidthFillUint8, ///< 8-bit Fill operation.
EfiIsaIoWidthFillUint16, ///< 16-bit Fill operation.
EfiIsaIoWidthFillUint32, ///< 32-bit Fill operation.
EfiIsaIoWidthFillReserved,
EfiIsaIoWidthMaximum
} EFI_ISA_IO_PROTOCOL_WIDTH;
///
/// Attributes for the EFI_ISA_IO_PROTOCOL common DMA buffer allocations.
///
#define EFI_ISA_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE 0x080 ///< Map a memory range so write are combined.
#define EFI_ISA_IO_ATTRIBUTE_MEMORY_CACHED 0x800 ///< Map a memory range so all read and write accesses are cached.
#define EFI_ISA_IO_ATTRIBUTE_MEMORY_DISABLE 0x1000 ///< Disable a memory range.
///
/// Channel attribute for EFI_ISA_IO_PROTOCOL slave DMA requests
///
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_COMPATIBLE 0x001 ///< Set the speed of the DMA transfer in compatible mode.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_A 0x002 ///< Not supported.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_B 0x004 ///< Not supported.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_C 0x008 ///< Not supported.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_8 0x010 ///< Request 8-bit DMA transfers. Only available on channels 0..3.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_16 0x020 ///< Request 16-bit DMA transfers. Only available on channels 4..7.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE 0x040 ///< Request a single DMA transfer.
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE 0x080 ///< Request multiple DMA transfers until TC (Terminal Count) or EOP (End of Process).
#define EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_AUTO_INITIALIZE 0x100 ///< Automatically reload base and count at the end of the DMA transfer.
///
/// The DMA opreration type for EFI_ISA_IO_PROTOCOL DMA requests.
///
typedef enum {
///
/// A read operation from system memory by a bus master.
///
EfiIsaIoOperationBusMasterRead,
///
/// A write operation to system memory by a bus master.
///
EfiIsaIoOperationBusMasterWrite,
///
/// Provides both read and write access to system memory by both the processor
/// and a bus master. The buffer is coherent from both the processor's and the
/// bus master's point of view.
///
EfiIsaIoOperationBusMasterCommonBuffer,
///
/// A read operation from system memory by a slave device.
///
EfiIsaIoOperationSlaveRead,
///
/// A write operation to system memory by a slave master.
///
EfiIsaIoOperationSlaveWrite,
EfiIsaIoOperationMaximum
} EFI_ISA_IO_PROTOCOL_OPERATION;
/**
Performs ISA I/O and MMIO Read/Write Cycles
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@param[in] Width Specifies the width of the I/O or MMIO operation.
@param[in] Offset The offset into the ISA I/O or MMIO space to start the
operation.
@param[in] Count The number of I/O or MMIO operations to perform.
@param[in, out] Buffer For read operations, the destination buffer to store
the results. For write operations, the source buffer to
write data from.
@retval EFI_SUCCESS The data was successfully read from or written to the device.
@retval EFI_UNSUPPORTED The Offset is not valid for this device.
@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_ISA_IO_PROTOCOL_IO_MEM)(
IN EFI_ISA_IO_PROTOCOL *This,
IN EFI_ISA_IO_PROTOCOL_WIDTH Width,
IN UINT32 Offset,
IN UINTN Count,
IN OUT VOID *Buffer
);
///
/// Structure of functions for accessing ISA I/O and MMIO space.
///
typedef struct {
///
/// Read from ISA I/O or MMIO space.
///
EFI_ISA_IO_PROTOCOL_IO_MEM Read;
///
/// Write to ISA I/O or MMIO space.
///
EFI_ISA_IO_PROTOCOL_IO_MEM Write;
} EFI_ISA_IO_PROTOCOL_ACCESS;
/**
Copies data from one region of ISA MMIO space to another region of ISA
MMIO space.
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@param[in] Width Specifies the width of the MMIO copy operation.
@param[in] DestOffset The offset of the destination in ISA MMIO space.
@param[in] SrcOffset The offset of the source in ISA MMIO space.
@param[in] Count The number tranfers to perform for this copy operation.
@retval EFI_SUCCESS The data was copied sucessfully.
@retval EFI_UNSUPPORTED The DestOffset or SrcOffset is not valid for this device.
@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_ISA_IO_PROTOCOL_COPY_MEM)(
IN EFI_ISA_IO_PROTOCOL *This,
IN EFI_ISA_IO_PROTOCOL_WIDTH Width,
IN UINT32 DestOffset,
IN UINT32 SrcOffset,
IN UINTN Count
);
/**
Maps a memory region for DMA.
This function returns the device-specific addresses required to access system memory.
This function is used to map system memory for ISA DMA operations. All ISA DMA
operations must be performed through their mapped addresses, and such mappings must
be freed with EFI_ISA_IO_PROTOCOL.Unmap() after the DMA operation is completed.
If the DMA operation is a single read or write data transfer through an ISA bus
master, then EfiIsaIoOperationBusMasterRead or EfiIsaIoOperationBusMasterWrite
is used and the range is unmapped to complete the operation. If the DMA operation
is a single read or write data transfer through an ISA slave controller, then
EfiIsaIoOperationSlaveRead or EfiIsaIoOperationSlaveWrite is used and the range
is unmapped to complete the operation.
If performing a DMA read operation, all the data must be present in system memory before the Map() is performed. Similarly,
if performing a DMA write operation, the data must not be accessed in system
memory until EFI_ISA_IO_PROTOCOL.Unmap() is performed. Bus master operations that
require both read and write access or require multiple host device interactions
within the same mapped region must use EfiIsaIoOperationBusMasterCommonBuffer.
However, only memory allocated via the EFI_ISA_IO_PROTOCOL.AllocateBuffer() interface
is guaranteed to be able to be mapped for this operation type. In all mapping
requests the NumberOfBytes returned may be less than originally requested. It is
the caller's responsibility to make additional requests to complete the entire
transfer.
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@param[in] Operation Indicates the type of DMA (slave or bus master),
and if the DMA operation is going to read or
write to system memory.
@param[in] ChannelNumber The slave channel number to use for this DMA
operation. If Operation and ChannelAttributes
shows that this device performs bus mastering
DMA, then this field is ignored. The legal
range for this field is 0..7.
@param[in] ChannelAttributes A bitmask of the attributes used to configure
the slave DMA channel for this DMA operation.
See EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_* for the
legal bit combinations.
@param[in] HostAddress The system memory address to map to the device.
@param[in, out] NumberOfBytes On input the number of bytes to map. On
output the number of bytes that were mapped.
@param[out] DeviceAddress The resulting map address for the bus master
device to use to access the hosts HostAddress.
@param[out] Mapping A returned value that must be passed to into
EFI_ISA_IO_PROTOCOL.Unmap() to free all the the
resources associated with this map request.
@retval EFI_SUCCESS The range was mapped for the returned NumberOfBytes.
@retval EFI_INVALID_PARAMETER The Operation is undefined.
@retval EFI_INVALID_PARAMETER The HostAddress is undefined.
@retval EFI_UNSUPPORTED The HostAddress can not be mapped as a common buffer.
@retval EFI_DEVICE_ERROR The system hardware could not map the requested address.
@retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_IO_PROTOCOL_MAP)(
IN EFI_ISA_IO_PROTOCOL *This,
IN EFI_ISA_IO_PROTOCOL_OPERATION Operation,
IN UINT8 ChannelNumber OPTIONAL,
IN UINT32 ChannelAttributes,
IN VOID *HostAddress,
IN OUT UINTN *NumberOfBytes,
OUT EFI_PHYSICAL_ADDRESS *DeviceAddress,
OUT VOID **Mapping
);
/**
Unmaps a memory region that was previously mapped with EFI_ISA_IO_PROTOCOL.Map().
The EFI_ISA_IO_PROTOCOL.Map() operation is completed and any corresponding
resources are released. If the operation was EfiIsaIoOperationSlaveWrite
or EfiIsaIoOperationBusMasterWrite, the data is committed to system memory.
Any resources used for the mapping are freed.
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@param[in] Mapping The mapping value returned from EFI_ISA_IO_PROTOCOL.Map().
@retval EFI_SUCCESS The memory region was unmapped.
@retval EFI_DEVICE_ERROR The data was not committed to the target system memory.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_IO_PROTOCOL_UNMAP)(
IN EFI_ISA_IO_PROTOCOL *This,
IN VOID *Mapping
);
/**
Allocates pages that are suitable for an EfiIsaIoOperationBusMasterCommonBuffer
mapping.
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@param[in] Type The type allocation to perform.
@param[in] MemoryType The type of memory to allocate.
@param[in] Pages The number of pages to allocate.
@param[out] HostAddress A pointer to store the base address of the allocated range.
@param[in] Attributes The requested bit mask of attributes for the allocated range.
@retval EFI_SUCCESS The requested memory pages were allocated.
@retval EFI_INVALID_PARAMETER Type is invalid.
@retval EFI_INVALID_PARAMETER MemoryType is invalid.
@retval EFI_INVALID_PARAMETER HostAddress is NULL.
@retval EFI_UNSUPPORTED Attributes is unsupported.
@retval EFI_UNSUPPORTED The memory range specified by HostAddress, Pages,
and Type is not available for common buffer use.
@retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_IO_PROTOCOL_ALLOCATE_BUFFER)(
IN EFI_ISA_IO_PROTOCOL *This,
IN EFI_ALLOCATE_TYPE Type,
IN EFI_MEMORY_TYPE MemoryType,
IN UINTN Pages,
OUT VOID **HostAddress,
IN UINT64 Attributes
);
/**
Frees a common buffer that was allocated with EFI_ISA_IO_PROTOCOL.AllocateBuffer().
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@param[in] Pages The number of pages to free from the previously allocated common buffer.
@param[in] HostAddress The base address of the previously allocated common buffer.
@retval EFI_SUCCESS The requested memory pages were freed.
@retval EFI_INVALID_PARAMETER The memory was not allocated with EFI_ISA_IO.AllocateBufer().
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_IO_PROTOCOL_FREE_BUFFER)(
IN EFI_ISA_IO_PROTOCOL *This,
IN UINTN Pages,
IN VOID *HostAddress
);
/**
Flushes a DMA buffer, which forces all DMA posted write transactions to complete.
@param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance.
@retval EFI_SUCCESS The DMA buffers were flushed.
@retval EFI_DEVICE_ERROR The buffers were not flushed due to a hardware error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ISA_IO_PROTOCOL_FLUSH)(
IN EFI_ISA_IO_PROTOCOL *This
);
///
/// The EFI_ISA_IO_PROTOCOL provides the basic Memory, I/O, and DMA interfaces
/// used to abstract accesses to ISA controllers. There is one EFI_ISA_IO_PROTOCOL
/// instance for each ISA controller on a ISA bus. A device driver that wishes
/// to manage an ISA controller in a system will have to retrieve the
/// ISA_PCI_IO_PROTOCOL instance associated with the ISA controller.
///
struct _EFI_ISA_IO_PROTOCOL {
EFI_ISA_IO_PROTOCOL_ACCESS Mem;
EFI_ISA_IO_PROTOCOL_ACCESS Io;
EFI_ISA_IO_PROTOCOL_COPY_MEM CopyMem;
EFI_ISA_IO_PROTOCOL_MAP Map;
EFI_ISA_IO_PROTOCOL_UNMAP Unmap;
EFI_ISA_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;
EFI_ISA_IO_PROTOCOL_FREE_BUFFER FreeBuffer;
EFI_ISA_IO_PROTOCOL_FLUSH Flush;
///
/// The list of I/O , MMIO, DMA, and Interrupt resources associated with the
/// ISA controller abstracted by this instance of the EFI_ISA_IO_PROTOCOL.
///
EFI_ISA_ACPI_RESOURCE_LIST *ResourceList;
///
/// The size, in bytes, of the ROM image.
///
UINT32 RomSize;
///
/// A pointer to the in memory copy of the ROM image. The ISA Bus Driver is responsible
/// for allocating memory for the ROM image, and copying the contents of the ROM to memory
/// during ISA Bus initialization.
///
VOID *RomImage;
};
extern EFI_GUID gEfiIsaIoProtocolGuid;
#endif

88
IntelFrameworkModulePkg/Include/Protocol/OEMBadging.h Normal file
View File

@ -0,0 +1,88 @@
/** @file
The OEM Badging Protocol defines the interface to get the OEM badging
image with the display attribute. This protocol can be produced based on OEM badging images.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __EFI_OEM_BADGING_H__
#define __EFI_OEM_BADGING_H__
//
// GUID for EFI OEM Badging Protocol
//
#define EFI_OEM_BADGING_PROTOCOL_GUID \
{ 0x170e13c0, 0xbf1b, 0x4218, {0x87, 0x1d, 0x2a, 0xbd, 0xc6, 0xf8, 0x87, 0xbc } }
typedef struct _EFI_OEM_BADGING_PROTOCOL EFI_OEM_BADGING_PROTOCOL;
typedef enum {
EfiBadgingFormatBMP,
EfiBadgingFormatJPEG,
EfiBadgingFormatTIFF,
EfiBadgingFormatGIF,
EfiBadgingFormatUnknown
} EFI_BADGING_FORMAT;
typedef enum {
EfiBadgingDisplayAttributeLeftTop,
EfiBadgingDisplayAttributeCenterTop,
EfiBadgingDisplayAttributeRightTop,
EfiBadgingDisplayAttributeCenterRight,
EfiBadgingDisplayAttributeRightBottom,
EfiBadgingDisplayAttributeCenterBottom,
EfiBadgingDisplayAttributeLeftBottom,
EfiBadgingDisplayAttributeCenterLeft,
EfiBadgingDisplayAttributeCenter,
EfiBadgingDisplayAttributeCustomized
} EFI_BADGING_DISPLAY_ATTRIBUTE;
/**
Load an OEM badge image and return its data and attributes.
@param This The pointer to this protocol instance.
@param Instance The visible image instance is found.
@param Format The format of the image. Examples: BMP, JPEG.
@param ImageData The image data for the badge file. Currently only
supports the .bmp file format.
@param ImageSize The size of the image returned.
@param Attribute The display attributes of the image returned.
@param CoordinateX The X coordinate of the image.
@param CoordinateY The Y coordinate of the image.
@retval EFI_SUCCESS The image was fetched successfully.
@retval EFI_NOT_FOUND The specified image could not be found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_BADGING_GET_IMAGE)(
IN EFI_OEM_BADGING_PROTOCOL *This,
IN OUT UINT32 *Instance,
OUT EFI_BADGING_FORMAT *Format,
OUT UINT8 **ImageData,
OUT UINTN *ImageSize,
OUT EFI_BADGING_DISPLAY_ATTRIBUTE *Attribute,
OUT UINTN *CoordinateX,
OUT UINTN *CoordinateY
);
struct _EFI_OEM_BADGING_PROTOCOL {
EFI_BADGING_GET_IMAGE GetImage;
};
extern EFI_GUID gEfiOEMBadgingProtocolGuid;
#endif

94
IntelFrameworkModulePkg/Include/Protocol/VgaMiniPort.h Normal file
View File

@ -0,0 +1,94 @@
/** @file
The VGA Mini Port Protocol used to set the text display mode of a VGA controller.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __VGA_MINI_PORT_H_
#define __VGA_MINI_PORT_H_
///
/// Global ID for the EFI_VGA_MINI_PORT_PROTOCOL.
///
#define EFI_VGA_MINI_PORT_PROTOCOL_GUID \
{ \
0xc7735a2f, 0x88f5, 0x4882, {0xae, 0x63, 0xfa, 0xac, 0x8c, 0x8b, 0x86, 0xb3 } \
}
///
/// Forward declaration for the EFI_VGA_MINI_PORT_PROTOCOL.
///
typedef struct _EFI_VGA_MINI_PORT_PROTOCOL EFI_VGA_MINI_PORT_PROTOCOL;
/**
Sets the text display mode of a VGA controller.
Sets the text display mode of the VGA controller to the mode specified by
ModeNumber. A ModeNumber of 0 is a request for an 80x25 text mode. A
ModeNumber of 1 is a request for an 80x50 text mode. If ModeNumber is greater
than MaxModeNumber, then EFI_UNSUPPORTED is returned. If the VGA controller
is not functioning properly, then EFI_DEVICE_ERROR is returned. If the VGA
controller is sucessfully set to the mode number specified by ModeNumber, then
EFI_SUCCESS is returned.
@param[in] This A pointer to the EFI_VGA_MINI_PORT_PROTOCOL instance.
@param[in] ModeNumber The requested mode number. 0 for 80x25. 1 for 80x5.
@retval EFI_SUCCESS The mode number was set.
@retval EFI_UNSUPPORTED The mode number specified by ModeNumber is not supported.
@retval EFI_DEVICE_ERROR The device is not functioning properly.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_VGA_MINI_PORT_SET_MODE)(
IN EFI_VGA_MINI_PORT_PROTOCOL *This,
IN UINTN ModeNumber
);
struct _EFI_VGA_MINI_PORT_PROTOCOL {
EFI_VGA_MINI_PORT_SET_MODE SetMode;
///
/// MMIO base address of the VGA text mode framebuffer. Typically set to 0xB8000.
///
UINT64 VgaMemoryOffset;
///
/// I/O Port address for the VGA CRTC address register. Typically set to 0x3D4.
///
UINT64 CrtcAddressRegisterOffset;
///
/// I/O Port address for the VGA CRTC data register. Typically set to 0x3D5.
///
UINT64 CrtcDataRegisterOffset;
///
/// PCI Controller MMIO BAR index of the VGA text mode frame buffer. Typically
/// set to EFI_PCI_IO_PASS_THROUGH_BAR
///
UINT8 VgaMemoryBar;
///
/// PCI Controller I/O BAR index of the VGA CRTC address register. Typically
/// set to EFI_PCI_IO_PASS_THROUGH_BAR
///
UINT8 CrtcAddressRegisterBar;
///
/// PCI Controller I/O BAR index of the VGA CRTC data register. Typically set
/// to EFI_PCI_IO_PASS_THROUGH_BAR
///
UINT8 CrtcDataRegisterBar;
///
/// The maximum number of text modes that this VGA controller supports.
///
UINT8 MaxMode;
};
extern EFI_GUID gEfiVgaMiniPortProtocolGuid;
#endif

51
IntelFrameworkPkg/Include/Guid/BlockIo.h Normal file
View File

@ -0,0 +1,51 @@
/** @file
This file declares the hardware-device class GUIDs that may be used by the
PEIM that produces the Virtual Block I/O PPI.
These GUIDs are hardware-device class GUIDs that would be imported only by the
Virtual Block I/O PEIM. This virtual PEIM imports only the actual Block I/O
PPIs from the device-class ones listed here and published a single instance of
the Block I/O PPI for consumption by the File System PEIM. In the parlance of
the Framework DXE software stack, this Virtual Block I/O PEIM is actually
embodying the functionality of the partition driver. Thsi Virtual Block I/O
PEIM has to multiple the multiple possible instances of Block I/O and also know
how to parse at least El Torito for CD-ROM, and perhaps Master Boot Record(MBR)
and GUID Partition Table(GPT) in the future.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
These GUIDs are defined in Framework Recovery Specification Version 0.9
**/
#ifndef _PEI_BLOCK_IO_GUID_H_
#define _PEI_BLOCK_IO_GUID_H_
///
/// Global ID for an IDE class recovery device.
///
#define EFI_PEI_IDE_BLOCK_IO_PPI \
{ \
0x0964e5b22, 0x6459, 0x11d2, { 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
}
///
/// Global ID for a Floppy class recovery device.
///
#define EFI_PEI_144_FLOPPY_BLOCK_IO_PPI \
{ \
0xda6855bd, 0x07b7, 0x4c05, { 0x9e, 0xd8, 0xe2, 0x59, 0xfd, 0x36, 0x0e, 0x22 } \
}
extern EFI_GUID gEfiPeiIdeBlockIoPpiGuid;
extern EFI_GUID gEfiPei144FloppyBlockIoPpiGuid;
#endif

147
IntelFrameworkPkg/Include/Guid/Capsule.h Normal file
View File

@ -0,0 +1,147 @@
/** @file
Framework Capule related Definition.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
Capsule Spec Version 0.9
**/
#ifndef _CAPSULE_GUID_H__
#define _CAPSULE_GUID_H__
//
// This is the GUID of the capsule header of the image on disk.
//
#define EFI_CAPSULE_GUID \
{ \
0x3B6686BD, 0x0D76, 0x4030, {0xB7, 0x0E, 0xB5, 0x51, 0x9E, 0x2F, 0xC5, 0xA0 } \
}
//
// This is the GUID of the configuration results file created by the capsule
// application.
//
#define EFI_CONFIG_FILE_NAME_GUID \
{ \
0x98B8D59B, 0xE8BA, 0x48EE, {0x98, 0xDD, 0xC2, 0x95, 0x39, 0x2F, 0x1E, 0xDB } \
}
///
/// Bits in the flags field of the capsule header.
/// This flag is set if the capsule can support setup changes, and cleared if it cannot.
///
#define EFI_CAPSULE_HEADER_FLAG_SETUP 0x00000001
#define CAPSULE_BLOCK_DESCRIPTOR_SIGNATURE SIGNATURE_32 ('C', 'B', 'D', 'S')
//
// An array of these structs describe the blocks that make up a capsule for
// a capsule update.
//
typedef struct {
UINT64 Length; ///< Length of the data block.
EFI_PHYSICAL_ADDRESS Data; ///< Physical address of the data block.
UINT32 Signature; ///< CBDS.
UINT32 CheckSum; ///< To sum this structure to 0.
} FRAMEWORK_EFI_CAPSULE_BLOCK_DESCRIPTOR;
typedef struct {
EFI_GUID OemGuid;
UINT32 HeaderSize;
//
// UINT8 OemHdrData[];
//
} EFI_CAPSULE_OEM_HEADER;
typedef struct {
///
/// A defined GUID that indicates the start of a capsule.
///
EFI_GUID CapsuleGuid;
///
/// The size of the EFI_CAPSULE_HEADER structure.
///
UINT32 HeaderSize;
///
/// A bit-mapped list describing the capsule's attributes.
/// All undefined bits should be written as zero (0).
///
UINT32 Flags;
///
/// The length in bytes (27,415 for an image containing 27,415 bytes) of the entire image
/// including all headers. If this value is greater than the size of the data presented in
/// the capsule body, the image is separated across multiple media. If this
/// value is less than the size of the data, it is an error.
///
UINT32 CapsuleImageSize;
///
/// A zero-based number that enables a capsule to be split into pieces and then
/// recombined for easier transfer across media with limited size. The lower the
/// SequenceNumber, the earlier in the final image that the part of the capsule is to
/// appear. In capsules that are not split, this value shall be zero.
///
UINT32 SequenceNumber;
///
/// Used to group the various pieces of a split capsule to ensure that they comprise the
/// same base image. It is valid for this item to be zero, in which case the capsule cannot
/// be split into components.
///
EFI_GUID InstanceId;
///
/// The offset in bytes from the beginning of the header to the start of an EFI string that
/// contains a description of the identity of the subcapsules that make up the capsule. If
/// the capsule is not split, this value should be zero. The same string should be
/// presented for all subcapsules that constitute the same capsule.
///
UINT32 OffsetToSplitInformation;
///
/// The offset in bytes from the beginning of the header to the start of the part of the
/// capsule that is to be transferred to DXE.
///
UINT32 OffsetToCapsuleBody;
///
/// The offset in bytes from the beginning of the header to the start of the OEM-defined
/// header. This value must be less than OffsetToCapsuleBody.
///
UINT32 OffsetToOemDefinedHeader;
///
/// The offset in bytes from the beginning of the header to the start of human-readable
/// text that describes the entity that created the capsule. This value must be less than OffsetToCapsuleBody.
///
UINT32 OffsetToAuthorInformation;
///
/// The offset in bytes from the beginning of the header to the start of human-readable
/// text that describes the revision of the capsule and/or the capsule's contents. This
/// value must be less than OffsetToCapsuleBody.
///
UINT32 OffsetToRevisionInformation;
///
/// The offset in bytes from the beginning of the header to the start of a one-line (less
/// than 40 Unicode characters in any language) description of the capsule. It is intended
/// to be used by OS-present applications when providing a list of capsules from which
/// the user can choose. This value must be less than OffsetToCapsuleBody.
///
UINT32 OffsetToShortDescription;
///
/// The offset in bytes from the beginning of the header to the start of an EFI string
///
UINT32 OffsetToLongDescription;
///
/// This field is reserved for future use by this specification. For future compatibility,
/// this field must be set to zero
///
UINT32 OffsetToApplicableDevices;
} FRAMEWORK_EFI_CAPSULE_HEADER;
extern EFI_GUID gEfiCapsuleGuid;
extern EFI_GUID gEfiConfigFileNameGuid;
#endif

2935
IntelFrameworkPkg/Include/Guid/DataHubRecords.h Normal file
View File

File diff suppressed because it is too large Load Diff

36
IntelFrameworkPkg/Include/Guid/FirmwareFileSystem.h Normal file
View File

@ -0,0 +1,36 @@
/** @file
Guid used to define the Firmware File System. See the Framework Firmware
File System Specification for more details.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
Guids defined in Firmware File System Spec 0.9.
**/
#ifndef __FIRMWARE_FILE_SYSTEM_GUID_H__
#define __FIRMWARE_FILE_SYSTEM_GUID_H__
///
/// GUIDs defined by the FFS specification.
///
#define EFI_FIRMWARE_FILE_SYSTEM_GUID \
{ 0x7A9354D9, 0x0468, 0x444a, {0x81, 0xCE, 0x0B, 0xF6, 0x17, 0xD8, 0x90, 0xDF }}
typedef UINT16 EFI_FFS_FILE_TAIL;
#define FFS_ATTRIB_TAIL_PRESENT 0x01
#define FFS_ATTRIB_RECOVERY 0x02
#define FFS_ATTRIB_HEADER_EXTENSION 0x04
extern EFI_GUID gEfiFirmwareFileSystemGuid;
#endif

33
IntelFrameworkPkg/Include/Guid/SmmCommunicate.h Normal file
View File

@ -0,0 +1,33 @@
/** @file
Definitions EFI_SMM_COMMUNICATE_HEADER used by EFI_SMM_BASE_PROTOCOL.Communicate()
functions.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
GUIDs defined in SmmCis spec version 0.9.
**/
#ifndef _SMM_COMMUNICATE_GUID_H_
#define _SMM_COMMUNICATE_GUID_H_
///
/// Inconsistent with specification here:
/// GUID definition format has been changed, because the GUID format in the Framework specification is incorrect.
///
#define SMM_COMMUNICATE_HEADER_GUID \
{ \
0xf328e36c, 0x23b6, 0x4a95, {0x85, 0x4b, 0x32, 0xe1, 0x95, 0x34, 0xcd, 0x75 } \
}
extern EFI_GUID gSmmCommunicateHeaderGuid;
#endif

60
IntelFrameworkPkg/Include/Guid/SmramMemoryReserve.h Normal file
View File

@ -0,0 +1,60 @@
/** @file
Definition of GUIDed HOB for reserving SMRAM regions.
This file defines:
* the GUID used to identify the GUID HOB for reserving SMRAM regions.
* the data structure of SMRAM descriptor to describe SMRAM candidate regions
* values of state of SMRAM candidate regions
* the GUID specific data structure of HOB for reserving SMRAM regions.
This GUIDed HOB can be used to convey the existence of the T-SEG reservation and H-SEG usage
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
GUIDs defined in SmmCis spec version 0.9.
**/
#ifndef _EFI_SMM_PEI_SMRAM_MEMORY_RESERVE_H_
#define _EFI_SMM_PEI_SMRAM_MEMORY_RESERVE_H_
#define EFI_SMM_PEI_SMRAM_MEMORY_RESERVE \
{ \
0x6dadf1d1, 0xd4cc, 0x4910, {0xbb, 0x6e, 0x82, 0xb1, 0xfd, 0x80, 0xff, 0x3d } \
}
/**
* GUID specific data structure of HOB for reserving SMRAM regions.
*
* Inconsistent with specification here:
* EFI_HOB_SMRAM_DESCRIPTOR_BLOCK has been changed to EFI_SMRAM_HOB_DESCRIPTOR_BLOCK.
* This inconsistency is kept in code in order for backward compatibility.
**/
typedef struct {
///
/// Designates the number of possible regions in the system
/// that can be usable for SMRAM.
///
/// Inconsistent with specification here:
/// In Framework SMM CIS 0.91 specification, it defines the field type as UINTN.
/// However, HOBs are supposed to be CPU neutral, so UINT32 should be used instead.
///
UINT32 NumberOfSmmReservedRegions;
///
/// Used throughout this protocol to describe the candidate
/// regions for SMRAM that are supported by this platform.
///
EFI_SMRAM_DESCRIPTOR Descriptor[1];
} EFI_SMRAM_HOB_DESCRIPTOR_BLOCK;
extern EFI_GUID gEfiSmmPeiSmramMemoryReserveGuid;
#endif

79
IntelFrameworkPkg/Include/Ppi/BootScriptExecuter.h Normal file
View File

@ -0,0 +1,79 @@
/** @file
This file declares the Boot Script Executer PPI.
This PPI is published by a PEIM upon dispatch and provides an execution engine for the
Framework boot script. This PEIM should be platform neutral and have no specific knowledge of
platform instructions or other information. The ability to interpret the boot script depends on the
abundance of other PPIs that are available. For example, if the script requests an SMBus command
execution, the PEIM looks for a relevant PPI that is available to execute it, rather than executing it
by issuing the native IA-32 instruction.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in Framework of EFI BootScript spec.
Version 0.91.
**/
#ifndef _PEI_BOOT_SCRIPT_EXECUTER_PPI_H_
#define _PEI_BOOT_SCRIPT_EXECUTER_PPI_H_
#define EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI_GUID \
{ \
0xabd42895, 0x78cf, 0x4872, {0x84, 0x44, 0x1b, 0x5c, 0x18, 0x0b, 0xfb, 0xff } \
}
typedef struct _EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI;
/**
Executes the Framework boot script table.
@param PeiServices A pointer to the system PEI Services Table.
@param This A pointer to the EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI instance.
@param Address The physical memory address where the table is stored.
It must be zero if the table to be executed is stored in
a firmware volume file.
@param FvFile The firmware volume file name that contains the table to
be executed. It must be NULL if the table to be executed
is stored in physical memory.
@retval EFI_SUCCESS The boot script table was executed successfully.
@retval EFI_INVALID_PARAMETER Address is zero and FvFile is NULL.
@retval EFI_NOT_FOUND The file name specified in FvFile cannot be found.
@retval EFI_UNSUPPORTED The format of the boot script table is invalid.
Or, an unsupported opcode occurred in the table.
Or there were opcode execution errors, such as an
insufficient dependency.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_BOOT_SCRIPT_EXECUTE)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI *This,
IN EFI_PHYSICAL_ADDRESS Address,
IN EFI_GUID *FvFile OPTIONAL
);
///
/// EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI produces the function which interprets and
/// executes the Framework boot script table.
///
struct _EFI_PEI_BOOT_SCRIPT_EXECUTER_PPI {
///
/// Executes a boot script table.
///
EFI_PEI_BOOT_SCRIPT_EXECUTE Execute;
};
extern EFI_GUID gEfiPeiBootScriptExecuterPpiGuid;
#endif

68
IntelFrameworkPkg/Include/Ppi/FindFv.h Normal file
View File

@ -0,0 +1,68 @@
/** @file
This file declares FindFv PPI, which is used to locate FVs that contain PEIMs in PEI.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in PEI CIS
Version 0.91.
**/
#ifndef _FIND_FV_H_
#define _FIND_FV_H_
///
/// Inconsistent with specification here:
/// GUID value format has been changed to the standard GUID format.
///
#define EFI_PEI_FIND_FV_PPI_GUID \
{ \
0x36164812, 0xa023, 0x44e5, {0xbd, 0x85, 0x5, 0xbf, 0x3c, 0x77, 0x0, 0xaa } \
}
typedef struct _EFI_PEI_FIND_FV_PPI EFI_PEI_FIND_FV_PPI;
/**
This interface returns the base address of the firmware volume whose index
was passed in FvNumber. Once this function reports a firmware volume
index/base address pair, that index/address pairing must continue throughout PEI.
@param PeiServices The pointer to the PEI Services Table.
@param This Interface pointer that implements the Find FV service.
@param FvNumber The index of the firmware volume to locate.
@param FvAddress The address of the volume to discover.
@retval EFI_SUCCESS An additional firmware volume was found.
@retval EFI_OUT_OF_RESOURCES There are no firmware volumes for the given FvNumber.
@retval EFI_INVALID_PARAMETER *FvAddress is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_FIND_FV_FINDFV)(
IN EFI_PEI_FIND_FV_PPI *This,
IN EFI_PEI_SERVICES **PeiServices,
IN UINT8 *FvNumber,
IN OUT EFI_FIRMWARE_VOLUME_HEADER **FVAddress
);
/**
Hardware mechanisms for locating FVs in a platform vary widely.
EFI_PEI_FIND_FV_PPI serves to abstract this variation so that the
PEI Foundation can remain standard across a wide variety of platforms.
**/
struct _EFI_PEI_FIND_FV_PPI {
EFI_PEI_FIND_FV_FINDFV FindFv; ///< Service that abstracts the location of additional firmware volumes.
};
extern EFI_GUID gEfiFindFvPpiGuid;
#endif

68
IntelFrameworkPkg/Include/Ppi/FvLoadFile.h Normal file
View File

@ -0,0 +1,68 @@
/** @file
Load image file from fv to memory.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in PEI CIS spec Version 0.91.
**/
#ifndef _FV_FILE_LOADER_PPI_H_
#define _FV_FILE_LOADER_PPI_H_
#define EFI_PEI_FV_FILE_LOADER_GUID \
{ \
0x7e1f0d85, 0x4ff, 0x4bb2, {0x86, 0x6a, 0x31, 0xa2, 0x99, 0x6a, 0x48, 0xa8 } \
}
typedef struct _EFI_PEI_FV_FILE_LOADER_PPI EFI_PEI_FV_FILE_LOADER_PPI;
/**
Loads a PEIM into memory for subsequent execution.
@param This Interface pointer that implements the Load File PPI instance.
@param FfsHeader The pointer to the FFS header of the file to load.
@param ImageAddress The pointer to the address of the loaded Image
@param ImageSize The pointer to the size of the loaded image.
@param EntryPoint The pointer to the entry point of the image.
@retval EFI_SUCCESS The image was loaded successfully.
@retval EFI_OUT_OF_RESOURCES There was not enough memory.
@retval EFI_INVALID_PARAMETER The contents of the FFS file did not
contain a valid PE/COFF image that could be loaded.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_FV_LOAD_FILE)(
IN EFI_PEI_FV_FILE_LOADER_PPI *This,
IN EFI_FFS_FILE_HEADER *FfsHeader,
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
OUT UINT64 *ImageSize,
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
);
/**
This PPI is a pointer to the Load File service. This service will be
published by a PEIM. The PEI Foundation will use this service to
launch the known non-XIP PE/COFF PEIM images. This service may
depend upon the presence of the EFI_PEI_PERMANENT_MEMORY_INSTALLED_PPI.
**/
struct _EFI_PEI_FV_FILE_LOADER_PPI {
///
/// Loads a PEIM into memory for subsequent execution.
///
EFI_PEI_FV_LOAD_FILE FvLoadFile;
};
extern EFI_GUID gEfiPeiFvFileLoaderPpiGuid;
#endif

110
IntelFrameworkPkg/Include/Ppi/PciCfg.h Normal file
View File

@ -0,0 +1,110 @@
/** @file
This file declares the PciCfg PPI used to access the PCI configuration space in PEI
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in PEI CIS
Version 0.91.
**/
#ifndef __PEI_PCI_CFG_H__
#define __PEI_PCI_CFG_H__
#include <Ppi/PciCfg2.h>
//
// Get the common definitions for EFI_PEI_PCI_CFG_PPI_WIDTH.
//
#define EFI_PEI_PCI_CFG_PPI_INSTALLED_GUID \
{ \
0xe1f2eba0, 0xf7b9, 0x4a26, {0x86, 0x20, 0x13, 0x12, 0x21, 0x64, 0x2a, 0x90 } \
}
typedef struct _EFI_PEI_PCI_CFG_PPI EFI_PEI_PCI_CFG_PPI;
#define PEI_PCI_CFG_ADDRESS(bus, dev, func, reg) ( \
(UINT64) ((((UINTN) bus) << 24) + (((UINTN) dev) << 16) + (((UINTN) func) << 8) + ((UINTN) reg)) \
) & 0x00000000ffffffff
/**
PCI read and write operation.
@param PeiServices An indirect pointer to the PEI Services Table
published by the PEI Foundation.
@param This Pointer to local data for the interface.
@param Width The width of the access. Enumerated in bytes.
@param Address The physical address of the access.
@param Buffer A pointer to the buffer of data.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_NOT_YET_AVAILABLE The service has not been installed.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_PCI_CFG_PPI_IO)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_PCI_CFG_PPI *This,
IN EFI_PEI_PCI_CFG_PPI_WIDTH Width,
IN UINT64 Address,
IN OUT VOID *Buffer
);
/**
PCI read-modify-write operation.
@param PeiServices An indirect pointer to the PEI Services Table
published by the PEI Foundation.
@param This The pointer to local data for the interface.
@param Width The width of the access. Enumerated in bytes.
@param Address The physical address of the access.
@param SetBits Value of the bits to set.
@param ClearBits Value of the bits to clear.
@retval EFI_SUCCESS The function completed successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_PCI_CFG_PPI_RW)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_PCI_CFG_PPI *This,
IN EFI_PEI_PCI_CFG_PPI_WIDTH Width,
IN UINT64 Address,
IN UINTN SetBits,
IN UINTN ClearBits
);
/**
The EFI_PEI_PCI_CFG_PPI interfaces are used to abstract accesses to PCI
controllers behind a PCI root bridge controller.
**/
struct _EFI_PEI_PCI_CFG_PPI {
///
/// PCI read services. See the Read() function description.
///
EFI_PEI_PCI_CFG_PPI_IO Read;
///
/// PCI write services. See the Write() function description.
///
EFI_PEI_PCI_CFG_PPI_IO Write;
///
/// PCI read-modify-write services. See the Modify() function description.
///
EFI_PEI_PCI_CFG_PPI_RW Modify;
};
extern EFI_GUID gEfiPciCfgPpiInServiceTableGuid;
#endif

132
IntelFrameworkPkg/Include/Ppi/ReadOnlyVariable.h Normal file
View File

@ -0,0 +1,132 @@
/** @file
This file declares the Read-only Variable Service PPI, which is required by the framework spec.
These services provide a lightweight, read-only variant of the full EFI variable services. The
reason that these services are read-only is to reduce the complexity of flash management. Also,
some implementation of the PEI may use the same physical flash part for variable and PEIM
storage. As such, a write command to certain technologies would alter the contents of the entire part,
making the PEIM execution in the original position not follow the required flow.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in PEI CIS
Version 0.91.
**/
#ifndef __PEI_READ_ONLY_VARIABLE_PPI_H__
#define __PEI_READ_ONLY_VARIABLE_PPI_H__
#define EFI_PEI_READ_ONLY_VARIABLE_ACCESS_PPI_GUID \
{ \
0x3cdc90c6, 0x13fb, 0x4a75, {0x9e, 0x79, 0x59, 0xe9, 0xdd, 0x78, 0xb9, 0xfa } \
}
typedef struct _EFI_PEI_READ_ONLY_VARIABLE_PPI EFI_PEI_READ_ONLY_VARIABLE_PPI;
///
/// Variable attributes.
///@{
#define EFI_VARIABLE_NON_VOLATILE 0x00000001
#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002
#define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004
///
/// Inconsistent with specification here:
/// In Framework Spec, PeiCis0.91, neither the macro or its value is defined.
/// Keeping this inconsistancy for backward compatibility.
///
#define EFI_VARIABLE_READ_ONLY 0x00000008
///@}
/**
Get Variable value by Name and GUID pair.
@param[in] PeiServices An indirect pointer to the PEI Services Table published
by the PEI Foundation.
@param[in] VariableName A NULL-terminated Unicode string that is the name of the vendor's variable.
@param[in] VendorGuid A unique identifier for the vendor.
@param[out] Attributes This OPTIONAL parameter may be either NULL or
a pointer to the location in which to return
the attributes bitmask for the variable.
@param[in,out] DataSize On input, the size in bytes of the return Data buffer.
On output, the size of data returned in Data.
@param[out] Data The buffer to return the contents of the variable.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_NOT_FOUND The variable was not found.
@retval EFI_BUFFER_TOO_SMALL The BufferSize is too small for the result.
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
@retval EFI_DEVICE_ERROR The variable could not be retrieved due to a hardware error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_GET_VARIABLE)(
IN EFI_PEI_SERVICES **PeiServices,
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data
);
/**
This function can be called multiple times to retrieve the VariableName
and VendorGuid of all variables currently available in the system. On each call
to GetNextVariableName(), the previous results are passed into the interface,
and on output the interface returns the next variable name data. When the
entire variable list has been returned, the error EFI_NOT_FOUND is returned.
@param[in] PeiServices An indirect pointer to the PEI Services Table
published by the PEI Foundation.
@param[in] VariableNameSize The size of the VariableName buffer.
@param[in] VariableName On input, supplies the last VariableName that was
returned by GetNextVariableName(). On output,
returns the Null-terminated Unicode string of the
current variable.
@param[in] VendorGuid On input, supplies the last VendorGuid that was
returned by GetNextVariableName(). On output,
returns the VendorGuid of the current variable.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_NOT_FOUND The next variable was not found.
@retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the result.
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
@retval EFI_DEVICE_ERROR The variable name could not be retrieved due to
a hardware error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_GET_NEXT_VARIABLE_NAME)(
IN EFI_PEI_SERVICES **PeiServices,
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
);
///
/// This PPI provides a lightweight, read-only variant of the full EFI
/// variable services.
///
struct _EFI_PEI_READ_ONLY_VARIABLE_PPI {
///
/// Inconsistent with specification here:
/// In Framework Spec, PeiCis0.91, the field is named as GetVariable and GetNextVariableName.
/// Keeping this inconsistancy for backward compatibility.
///
EFI_PEI_GET_VARIABLE PeiGetVariable; ///< A service to ascertain a given variable name.
EFI_PEI_GET_NEXT_VARIABLE_NAME PeiGetNextVariableName; ///< A service to ascertain a variable based upon a given, known variable
};
extern EFI_GUID gEfiPeiReadOnlyVariablePpiGuid;
#endif /* __PEI_READ_ONLY_VARIABLE_PPI_H__ */

76
IntelFrameworkPkg/Include/Ppi/S3Resume.h Normal file
View File

@ -0,0 +1,76 @@
/** @file
This file declares S3 Resume PPI which accomplishes the firmware S3 resume boot path
and transfers control to OS.
This PPI is published by the S3 resume PEIM and can be used on the S3 resume boot path to
restore the platform to its preboot configuration and transfer control to OS. The information that is
required for an S3 resume can be saved during the normal boot path using
EFI_ACPI_S3_SAVE_PROTOCOL. This presaved information can then be restored in the S3
resume boot path using EFI_PEI_S3_RESUME_PPI. Architecturally, the S3 resume PEIM is the
last PEIM to be dispatched in the S3 resume boot path.
Before using this PPI, the caller must ensure the necessary information for the S3 resume, such as
the following, is available for the S3 resume boot path:
- EFI_ACPI_S3_RESUME_SCRIPT_TABLE script table. Type
EFI_ACPI_S3_RESUME_SCRIPT_TABLE is defined in the Intel Platform Innovation
Framework for EFI Boot Script Specification.
- OS waking vector.
- The reserved memory range to be used for the S3 resume.
Otherwise, the S3 resume boot path may fail.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in Framework for EFI S3 Resume Boot Path spec.
Version 0.9.
**/
#ifndef __PEI_S3_RESUME_PPI_H__
#define __PEI_S3_RESUME_PPI_H__
#define EFI_PEI_S3_RESUME_PPI_GUID \
{ \
0x4426CCB2, 0xE684, 0x4a8a, {0xAE, 0x40, 0x20, 0xD4, 0xB0, 0x25, 0xB7, 0x10 } \
}
typedef struct _EFI_PEI_S3_RESUME_PPI EFI_PEI_S3_RESUME_PPI;
/**
Restores the platform to its preboot configuration for an S3 resume and
jumps to the OS waking vector.
@param PeiServices The pointer to the PEI Services Table
@retval EFI_ABORTED Execution of the S3 resume boot script table failed.
@retval EFI_NOT_FOUND Could not be locate some necessary information that
is used for the S3 resume boot path d.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_S3_RESUME_PPI_RESTORE_CONFIG)(
IN EFI_PEI_SERVICES **PeiServices
);
/**
EFI_PEI_S3_RESUME_PPI accomplishes the firmware S3 resume boot
path and transfers control to OS.
**/
struct _EFI_PEI_S3_RESUME_PPI {
///
/// Restores the platform to its preboot configuration for an S3 resume and
/// jumps to the OS waking vector.
///
EFI_PEI_S3_RESUME_PPI_RESTORE_CONFIG S3RestoreConfig;
};
extern EFI_GUID gEfiPeiS3ResumePpiGuid;
#endif

107
IntelFrameworkPkg/Include/Ppi/SectionExtraction.h Normal file
View File

@ -0,0 +1,107 @@
/** @file
This file declares the Section Extraction PPI.
This PPI is defined in PEI CIS version 0.91. It supports encapsulating sections,
such as GUIDed sections used to authenticate the file encapsulation of other domain-specific wrapping.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __SECTION_EXTRACTION_H__
#define __SECTION_EXTRACTION_H__
#define EFI_PEI_SECTION_EXTRACTION_PPI_GUID \
{ \
0x4F89E208, 0xE144, 0x4804, {0x9E, 0xC8, 0x0F, 0x89, 0x4F, 0x7E, 0x36, 0xD7 } \
}
typedef struct _EFI_PEI_SECTION_EXTRACTION_PPI EFI_PEI_SECTION_EXTRACTION_PPI;
//
// Bit values for AuthenticationStatus
//
#define EFI_AUTH_STATUS_PLATFORM_OVERRIDE 0x01
#define EFI_AUTH_STATUS_IMAGE_SIGNED 0x02
#define EFI_AUTH_STATUS_NOT_TESTED 0x04
#define EFI_AUTH_STATUS_TEST_FAILED 0x08
/**
The function is used to retrieve a section from within a section file.
It will retrieve both encapsulation sections and leaf sections in their entirety,
exclusive of the section header.
@param PeiServices The pointer to the PEI Services Table.
@param This Indicates the calling context
@param SectionType The pointer to an EFI_SECTION_TYPE. If
SectionType == NULL, the contents of the entire
section are returned in Buffer. If SectionType
is not NULL, only the requested section is returned.
@param SectionDefinitionGuid The pointer to an EFI_GUID.
If SectionType == EFI_SECTION_GUID_DEFINED,
SectionDefinitionGuid indicates for which section
GUID to search. If SectionType != EFI_SECTION_GUID_DEFINED,
SectionDefinitionGuid is unused and is ignored.
@param SectionInstance If SectionType is not NULL, indicates which
instance of the requested section type to return.
@param Buffer The pointer to a pointer to a buffer in which the
section contents are returned.
@param BufferSize A pointer to a caller-allocated UINT32. On input,
*BufferSize indicates the size in bytes of the
memory region pointed to by Buffer. On output,
*BufferSize contains the number of bytes required
to read the section.
@param AuthenticationStatus A pointer to a caller-allocated UINT32 in
which any metadata from encapsulating GUID-defined
sections is returned.
@retval EFI_SUCCESS The section was successfully processed, and the section
contents were returned in Buffer.
@retval EFI_PROTOCOL_ERROR A GUID-defined section was encountered in
the file with its EFI_GUIDED_SECTION_PROCESSING_REQUIRED
bit set, but there was no corresponding GUIDed
Section Extraction Protocol in the handle database.
*Buffer is unmodified.
@retval EFI_NOT_FOUND The requested section does not exist.*Buffer is
unmodified.
@retval EFI_OUT_OF_RESOURCES The system has insufficient resources to process
the request.
@retval EFI_INVALID_PARAMETER The SectionStreamHandle does not exist.
@retval EFI_WARN_TOO_SMALL The size of the input buffer is insufficient to
contain the requested section. The input buffer
is filled and contents are section contents are
truncated.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_GET_SECTION)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SECTION_EXTRACTION_PPI *This,
IN EFI_SECTION_TYPE *SectionType,
IN EFI_GUID *SectionDefinitionGuid, OPTIONAL
IN UINTN SectionInstance,
IN VOID **Buffer,
IN OUT UINT32 *BufferSize,
OUT UINT32 *AuthenticationStatus
);
/**
This PPI supports encapsulating sections, such as GUIDed sections used to
authenticate the file encapsulation of other domain-specific wrapping.
**/
struct _EFI_PEI_SECTION_EXTRACTION_PPI {
EFI_PEI_GET_SECTION GetSection; ///< Retrieves a section from within a section file.
};
extern EFI_GUID gEfiPeiSectionExtractionPpiGuid;
#endif

68
IntelFrameworkPkg/Include/Ppi/Security.h Normal file
View File

@ -0,0 +1,68 @@
/** @file
This file declares the Security Architectural PPI.
This PPI is installed by a platform PEIM that abstracts the security policy to the PEI
Foundation, namely the case of a PEIM's authentication state being returned during the PEI section
extraction process.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in PEI CIS.
Version 0.91.
**/
#ifndef __SECURITY_PPI_H__
#define __SECURITY_PPI_H__
#define EFI_PEI_SECURITY_PPI_GUID \
{ \
0x1388066e, 0x3a57, 0x4efa, {0x98, 0xf3, 0xc1, 0x2f, 0x3a, 0x95, 0x8a, 0x29 } \
}
typedef struct _EFI_PEI_SECURITY_PPI EFI_PEI_SECURITY_PPI;
/**
Allows the platform builder to implement a security policy in response
to varying file authentication states.
@param PeiServices The pointer to the PEI Services Table.
@param This Interface pointer that implements the particular
EFI_PEI_SECURITY_PPI instance.
@param AuthenticationStatus Status returned by the verification service as
part of section extraction.
@param FfsFileHeader The pointer to the file under review.
@param DeferExecution The pointer to a variable that alerts the PEI
Foundation to defer execution of a PEIM.
@retval EFI_SUCCESS The service performed its action successfully.
@retval EFI_SECURITY_VIOLATION The object cannot be trusted.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_PEI_SECURITY_AUTHENTICATION_STATE)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SECURITY_PPI *This,
IN UINT32 AuthenticationStatus,
IN EFI_FFS_FILE_HEADER *FfsFileHeader,
IN OUT BOOLEAN *DeferExecution
);
//
// PPI interface structure of Security PPI
//
struct _EFI_PEI_SECURITY_PPI {
FRAMEWORK_EFI_PEI_SECURITY_AUTHENTICATION_STATE AuthenticationState;
};
extern EFI_GUID gEfiPeiSecurityPpiGuid;
#endif

232
IntelFrameworkPkg/Include/Ppi/Smbus.h Normal file
View File

@ -0,0 +1,232 @@
/** @file
This file declares the Smbus PPI, which provides the basic I/O interfaces that a PEIM
uses to access its SMBus controller and the slave devices attached to it.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This PPI is defined in Framework of EFI SmBus PPI spec.
Version 0.9.
**/
#ifndef _PEI_SMBUS_PPI_H_
#define _PEI_SMBUS_PPI_H_
#include <Ppi/Smbus2.h>
#define EFI_PEI_SMBUS_PPI_GUID \
{ \
0xabd42895, 0x78cf, 0x4872, {0x84, 0x44, 0x1b, 0x5c, 0x18, 0xb, 0xfb, 0xda } \
}
typedef struct _EFI_PEI_SMBUS_PPI EFI_PEI_SMBUS_PPI;
/**
Executes an SMBus operation to an SMBus controller.
@param[in] PeiServices A pointer to the system PEI Services Table.
@param[in] This A pointer to the EFI_PEI_SMBUS_PPI instance.
@param[in] SlaveAddress The SMBUS hardware address to which the SMBUS
device is preassigned or allocated.
@param[in] Command This command is transmitted by the SMBus host
controller to the SMBus slave device, and the
interpretation is SMBus slave device specific.
@param[in] Operation Signifies which particular SMBus hardware protocol
instance to use to execute the SMBus transactions.
@param[in] PecCheck Defines if Packet Error Code (PEC) checking is
required for this operation.
@param[in, out] Length The number of bytes for this operation.
@param[in, out] Buffer Contains the value of data to execute to the SMBus
slave device.
@retval EFI_SUCCESS The last data that was returned from the access
matched the poll exit criteria.
@retval EFI_CRC_ERROR The checksum is not correct (PEC is incorrect).
@retval EFI_TIMEOUT Timeout expired before the operation was completed.
Timeout is determined by the SMBus host controller device.
@retval EFI_OUT_OF_RESOURCES The request could not be completed
due to a lack of resources.
@retval EFI_DEVICE_ERROR The request was not completed because a failure
was recorded in the Host Status Register bit.
@retval EFI_INVALID_PARAMETER The operation is not defined in EFI_SMBUS_OPERATION.
@retval EFI_INVALID_PARAMETER Length/Buffer is NULL for operations except for
EfiSmbusQuickRead and EfiSmbusQuickWrite. Length
is outside the range of valid values.
@retval EFI_UNSUPPORTED The SMBus operation or PEC is not supported.
@retval EFI_BUFFER_TOO_SMALL Buffer is not sufficient for this operation.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_SMBUS_PPI_EXECUTE_OPERATION)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SMBUS_PPI *This,
IN EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
IN EFI_SMBUS_DEVICE_COMMAND Command,
IN EFI_SMBUS_OPERATION Operation,
IN BOOLEAN PecCheck,
IN OUT UINTN *Length,
IN OUT VOID *Buffer
);
/**
This function is user-defined, and is called when the SlaveAddress/Data pair happens.
@param[in] PeiServices A pointer to the system PEI Services Table.
@param[in] This A pointer to the EFI_PEI_SMBUS_PPI instance.
@param[in] SlaveAddress The SMBUS hardware address to which the SMBUS
device is preassigned or allocated.
@param[in] Data Data of the SMBus host notify command, which denotes that
the caller wants to be called.
@return Status Code returned by callback function.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_SMBUS_NOTIFY_FUNCTION)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SMBUS_PPI *SmbusPpi,
IN EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
IN UINTN Data
);
/**
The ArpDevice() function enumerates either the entire bus or a specific
device identified by SmbusUdid.
@param[in] PeiServices A pointer to the system PEI Services Table.
@param[in] This A pointer to the EFI_PEI_SMBUS_PPI instance.
@param[in] ArpAll A Boolean expression that indicates if the host
drivers need to enumerate all the devices or to
enumerate only the device that is identified
by SmbusUdid. If ArpAll is TRUE, SmbusUdid and
SlaveAddress are optional and ignored if entered.
If ArpAll is FALSE, ArpDevice will enumerate
SmbusUdid, and the address will be at SlaveAddress.
@param[in] SmbusUdid The targeted SMBus Unique Device Identifier (UDID).
The UDID may not exist for SMBus devices with fixed
addresses.
@param[in, out] SlaveAddress The new SMBus address for the slave device for
which the operation is targeted.
This address may be NULL.
@retval EFI_SUCCESS The SMBus slave device address was set.
@retval EFI_INVALID_PARAMETER SlaveAddress is NULL.
@retval EFI_OUT_OF_RESOURCES The request could not be completed
due to a lack of resources.
@retval EFI_TIMEOUT The SMBus slave device did not respond.
@retval EFI_DEVICE_ERROR The request was not completed because the transaction failed.
@retval EFI_UNSUPPORTED ArpDevice() is not implemented by this PEIM.
This return value is not defined in the Framework Specification.
This return value was introduced in the PI Specification.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_SMBUS_PPI_ARP_DEVICE)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SMBUS_PPI *This,
IN BOOLEAN ArpAll,
IN EFI_SMBUS_UDID *SmbusUdid, OPTIONAL
IN OUT EFI_SMBUS_DEVICE_ADDRESS *SlaveAddress OPTIONAL
);
/**
The GetArpMap() function returns the mapping of all the SMBus devices
that are enumerated by the SMBus host driver.
@param[in] PeiServices A pointer to the system PEI Services Table.
@param[in] This A pointer to the EFI_PEI_SMBUS_PPI instance.
@param[in, out] Length The size of the buffer that contains the SMBus device map.
@param[in, out] SmbusDeviceMap The pointer to the device map as enumerated
by the SMBus controller driver.
@retval EFI_SUCCESS The device map was returned correctly in the buffer.
@retval EFI_UNSUPPORTED GetArpMap() are not implemented by this PEIM.
This return value was not defined in the Framework Specification.
This return value was introduced in the PI Specification.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_SMBUS_PPI_GET_ARP_MAP)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SMBUS_PPI *This,
IN OUT UINTN *Length,
IN OUT EFI_SMBUS_DEVICE_MAP **SmbusDeviceMap
);
/**
Allows a device driver to register for a callback when the bus driver detects a state that it needs to
propagate to other PEIMs that are registered for a callback.
The Notify() function registers all the callback functions to allow the
bus driver to call these functions when the SlaveAddress/Data pair occur.
All functions to be registered with EFI_PEI_SMBUS_PPI_NOTIFY must be of type
EFI_PEI_SMBUS_NOTIFY_FUNCTION.
@param[in] PeiServices A pointer to the system PEI Services Table.
@param[in] This A pointer to the EFI_PEI_SMBUS_PPI instance.
@param[in] SlaveAddress The address that the host controller detects as
sending a message and triggers all the registered functions.
@param[in] Data Data that the host controller detects as sending a message
and triggers all the registered functions.
@param[in] NotifyFunction The function to call when the bus driver
detects the SlaveAddress and Data pair.
@retval EFI_SUCCESS NotifyFunction has been registered.
@retval EFI_UNSUPPORTED Notify() are not implemented by this PEIM.
This return value is not defined in the Framework Specification.
This return value was introduced in the PI Specification.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PEI_SMBUS_PPI_NOTIFY)(
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_SMBUS_PPI *This,
IN EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
IN UINTN Data,
IN EFI_PEI_SMBUS_NOTIFY_FUNCTION NotifyFunction
);
///
/// Provides the basic I/O interfaces that a PEIM uses to access
/// its SMBus controller and the slave devices attached to it.
///
struct _EFI_PEI_SMBUS_PPI {
///
/// Executes the SMBus operation to an SMBus slave device.
///
EFI_PEI_SMBUS_PPI_EXECUTE_OPERATION Execute;
///
/// Allows an SMBus 2.0 device(s) to be Address Resolution Protocol (ARP)
///
EFI_PEI_SMBUS_PPI_ARP_DEVICE ArpDevice;
///
/// Allows a PEIM to retrieve the address that was allocated by the SMBus
/// host controller during enumeration/ARP.
///
EFI_PEI_SMBUS_PPI_GET_ARP_MAP GetArpMap;
///
/// Allows a driver to register for a callback to the SMBus host
/// controller driver when the bus issues a notification to the bus controller PEIM.
///
EFI_PEI_SMBUS_PPI_NOTIFY Notify;
};
extern EFI_GUID gEfiPeiSmbusPpiGuid;
#endif

128
IntelFrameworkPkg/Include/Protocol/AcpiS3Save.h Normal file
View File

@ -0,0 +1,128 @@
/** @file
This protocol is used to prepare all information that is needed for the S3 resume boot path. This
protocol is not required for all platforms.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of S3 Resume Boot Path Spec.
Version 0.9.
**/
#ifndef _ACPI_S3_SAVE_PROTOCOL_H_
#define _ACPI_S3_SAVE_PROTOCOL_H_
//
// Forward reference for pure ANSI compatability
//
typedef struct _EFI_ACPI_S3_SAVE_PROTOCOL EFI_ACPI_S3_SAVE_PROTOCOL;
//
// S3 Save Protocol GUID
//
#define EFI_ACPI_S3_SAVE_GUID \
{ \
0x125f2de1, 0xfb85, 0x440c, {0xa5, 0x4c, 0x4d, 0x99, 0x35, 0x8a, 0x8d, 0x38 } \
}
//
// Protocol Data Structures
//
/**
This function is used to:
- Prepare all information that is needed in the S3 resume boot path. This information can include
the following:
-- Framework boot script table
-- RSDT pointer
-- Reserved memory for the S3 resume
- Get the minimum legacy memory length (meaning below 1 MB) that is required for the S3 resume boot path.
If LegacyMemoryAddress is NULL, the firmware will be unable to jump into a real-mode
waking vector. However, it might still be able to jump into a flat-mode waking vector as long as the
OS provides a flat-mode waking vector. It is the caller's responsibility to ensure the
LegacyMemoryAddress is valid. If the LegacyMemoryAddress is higher than 1 MB,
EFI_INVALID_PARAMETER will be returned.
@param This A pointer to the EFI_ACPI_S3_SAVE_PROTOCOL instance.
@param LegacyMemoryAddress The base of legacy memory.
@retval EFI_SUCCESS All information was saved successfully.
@retval EFI_INVALID_PARAMETER The memory range is not located below 1 MB.
@retval EFI_OUT_OF_RESOURCES Resources were insufficient to save all the information.
@retval EFI_NOT_FOUND Some necessary information cannot be found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ACPI_S3_SAVE)(
IN EFI_ACPI_S3_SAVE_PROTOCOL * This,
IN VOID * LegacyMemoryAddress
);
/**
This function returns the size of the legacy memory (meaning below 1 MB) that is required during an S3
resume. Before the Framework-based firmware transfers control to the OS, it has to transition from
flat mode into real mode in case the OS supplies only a real-mode waking vector. This transition
requires a certain amount of legacy memory. After getting the size of legacy memory
below, the caller is responsible for allocating the legacy memory below 1 MB according to
the size that is returned. The specific implementation of allocating the legacy memory is out of the
scope of this specification.
@param This A pointer to the EFI_ACPI_S3_SAVE_PROTOCOL instance.
@param Size The returned size of legacy memory below 1MB.
@retval EFI_SUCCESS Size was successfully returned.
@retval EFI_INVALID_PARAMETER The pointer Size is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ACPI_GET_LEGACY_MEMORY_SIZE)(
IN EFI_ACPI_S3_SAVE_PROTOCOL * This,
OUT UINTN * Size
);
/**
The EFI_ACPI_S3_SAVE_PROTOCOL is responsible for preparing all the information that the
Framework needs to restore the platform's preboot state during an S3 resume boot. This
information can include the following:
- The Framework boot script table, containing all necessary operations to initialize the platform.
- ACPI table information, such as RSDT, through which the OS waking vector can be located.
- The range of reserved memory that can be used on the S3 resume boot path.
This protocol can be used after the Framework makes sure that the boot process is complete and
that no hardware has been left unconfigured. Where to call this protocol to save information is implementation-specific.
In the case of an EFI-aware OS, ExitBootServices() can be a choice to provide this hook.
The currently executing EFI OS loader image calls ExitBootServices()to terminate all boot
services. After ExitBootServices() successfully completes, the loader becomes responsible
for the continued operation of the system.
On a normal boot, ExitBootServices() checks if the platform supports S3 by looking for
EFI_ACPI_S3_SAVE_PROTOCOL. If the protocol exists, ExitBootServices()will assume
that the target platform supports an S3 resume and then call EFI_ACPI_S3_SAVE_PROTOCOL
to save the S3 resume information. The entire Framework boot script table will then be generated,
assuming the platform currently is in the preboot state.
**/
struct _EFI_ACPI_S3_SAVE_PROTOCOL {
///
/// Gets the size of legacy memory below 1 MB that is required for S3 resume.
///
EFI_ACPI_GET_LEGACY_MEMORY_SIZE GetLegacyMemorySize;
///
/// Prepare all information for an S3 resume.
///
EFI_ACPI_S3_SAVE S3Save;
};
extern EFI_GUID gEfiAcpiS3SaveProtocolGuid;
#endif

148
IntelFrameworkPkg/Include/Protocol/AcpiSupport.h Normal file
View File

@ -0,0 +1,148 @@
/** @file
This protocol provides some basic services to support publishing ACPI system tables. The
services handle many of the more mundane tasks that are required to publish a set of tables. The
services will:
- Generate common tables.
- Update the table links.
- Ensure that tables are properly aligned and use correct types of memory.
- Update checksum values and IDs.
- Complete the final installation of the tables.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework ACPI Specification.
Version 0.9.
**/
#ifndef _ACPI_SUPPORT_PROTOCOL_H_
#define _ACPI_SUPPORT_PROTOCOL_H_
#include <Protocol/AcpiSystemDescriptionTable.h>
typedef struct _EFI_ACPI_SUPPORT_PROTOCOL EFI_ACPI_SUPPORT_PROTOCOL;
//
// ACPI Support Protocol GUID
//
#define EFI_ACPI_SUPPORT_GUID \
{ \
0xdbff9d55, 0x89b7, 0x46da, {0xbd, 0xdf, 0x67, 0x7d, 0x3d, 0xc0, 0x24, 0x1d } \
}
//
// Protocol Member Functions
//
/**
Returns a requested ACPI table.
@param This A pointer to the EFI_ACPI_SUPPORT_PROTOCOL instance.
@param Index The zero-based index of the table to retrieve.
@param Table The pointer for returning the table buffer.
@param Version Updated with the ACPI versions to which this table belongs.
@param Handle The pointer for identifying the table.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_NOT_FOUND The requested index is too large and a table was not found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ACPI_GET_ACPI_TABLE)(
IN EFI_ACPI_SUPPORT_PROTOCOL *This,
IN INTN Index,
OUT VOID **Table,
OUT EFI_ACPI_TABLE_VERSION *Version,
OUT UINTN *Handle
);
/**
Used to add, remove, or update ACPI tables.
@param This A pointer to the EFI_ACPI_SUPPORT_PROTOCOL instance.
@param Table The pointer to the new table to add or update.
@param Checksum If TRUE, indicates that the checksum should be
calculated for this table.
@param Version Indicates to which version(s) of ACPI the table should be added.
@param Handle The pointer to the handle of the table to remove or update.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER *Handle was zero and Table was NULL.
@retval EFI_ABORTED Could not complete the desired action.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ACPI_SET_ACPI_TABLE)(
IN EFI_ACPI_SUPPORT_PROTOCOL *This,
IN VOID *Table OPTIONAL,
IN BOOLEAN Checksum,
IN EFI_ACPI_TABLE_VERSION Version,
IN OUT UINTN *Handle
);
/**
Causes one or more versions of the ACPI tables to be published in
the EFI system configuration tables.
The PublishTables() function installs the ACPI tables for the versions that are specified in
Version. No tables are published for Version equal to EFI_ACPI_VERSION_NONE. Once
published, tables will continue to be updated as tables are modified with
EFI_ACPI_SUPPORT_PROTOCOL.SetAcpiTable().
@param This A pointer to the EFI_ACPI_SUPPORT_PROTOCOL instance.
@param Version Indicates to which version(s) of ACPI the table should be published.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred and the function could not complete successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_ACPI_PUBLISH_TABLES)(
IN EFI_ACPI_SUPPORT_PROTOCOL *This,
IN EFI_ACPI_TABLE_VERSION Version
);
//
// ACPI Support Protocol
//
/**
This protocol provides some basic services to support publishing ACPI system
tables. The services handle many of the more mundane tasks that are required
to publish a set of tables.
**/
struct _EFI_ACPI_SUPPORT_PROTOCOL {
///
/// Returns a table specified by an index if it exists.
///
EFI_ACPI_GET_ACPI_TABLE GetAcpiTable;
///
/// Adds, removes, or updates ACPI tables.
///
EFI_ACPI_SET_ACPI_TABLE SetAcpiTable;
///
/// Publishes the ACPI tables.
///
EFI_ACPI_PUBLISH_TABLES PublishTables;
};
//
// Extern the GUID for protocol users.
//
extern EFI_GUID gEfiAcpiSupportProtocolGuid;
#endif

86
IntelFrameworkPkg/Include/Protocol/BootScriptSave.h Normal file
View File

@ -0,0 +1,86 @@
/** @file
This protocol is used to store or record various boot scripts into boot
script tables.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol defined in the Boot Script Specification, Version 0.91.
**/
#ifndef _BOOT_SCRIPT_SAVE_PROTOCOL_H_
#define _BOOT_SCRIPT_SAVE_PROTOCOL_H_
///
/// S3 Save Protocol GUID.
///
#define EFI_BOOT_SCRIPT_SAVE_PROTOCOL_GUID \
{ \
0x470e1529, 0xb79e, 0x4e32, {0xa0, 0xfe, 0x6a, 0x15, 0x6d, 0x29, 0xf9, 0xb2 } \
}
typedef struct _EFI_BOOT_SCRIPT_SAVE_PROTOCOL EFI_BOOT_SCRIPT_SAVE_PROTOCOL;
/**
Adds a record into a specified Framework boot script table.
@param This A pointer to the EFI_BOOT_SCRIPT_SAVE_PROTOCOL instance.
@param TableName The name of the script table. Currently, the only meaningful
value is EFI_ACPI_S3_RESUME_SCRIPT_TABLE.
@param OpCode The operation code (opcode) number.
@param ... The argument list that is specific to each opcode.
@retval EFI_SUCCESS The operation succeeded. A record was added into the specified script table.
@retval EFI_INVALID_PARAMETER The parameter is illegal, or the given boot script is not supported.
@retval EFI_OUT_OF_RESOURCES There is insufficient memory to store the boot script.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_BOOT_SCRIPT_WRITE)(
IN EFI_BOOT_SCRIPT_SAVE_PROTOCOL *This,
IN UINT16 TableName,
IN UINT16 OpCode,
...
);
/**
Closes the specified script table.
@param This A pointer to the EFI_BOOT_SCRIPT_SAVE_PROTOCOL instance.
@param TableName The name of the script table.
@param Address A pointer to the physical address where the table begins.
@retval EFI_SUCCESS The table was successfully returned.
@retval EFI_NOT_FOUND The specified table was not created previously.
@retval EFI_OUT_OF_RESOURCES Memory is insufficient to hold the reorganized boot script table.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_BOOT_SCRIPT_CLOSE_TABLE)(
IN EFI_BOOT_SCRIPT_SAVE_PROTOCOL *This,
IN UINT16 TableName,
OUT EFI_PHYSICAL_ADDRESS *Address
);
///
/// The EFI_BOOT_SCRIPT_SAVE_PROTOCOL publishes the Framework boot script abstractions
/// to store or record various boot scripts into boot script tables.
///
struct _EFI_BOOT_SCRIPT_SAVE_PROTOCOL {
EFI_BOOT_SCRIPT_WRITE Write; ///< Writes various boot scripts to a boot script table.
EFI_BOOT_SCRIPT_CLOSE_TABLE CloseTable; ///< Retrieves and closes a script table.
};
extern EFI_GUID gEfiBootScriptSaveProtocolGuid;
#endif

46
IntelFrameworkPkg/Include/Protocol/CpuIo.h Normal file
View File

@ -0,0 +1,46 @@
/** @file
This code abstracts the CPU IO Protocol which installed by some platform or chipset-specific
PEIM that abstracts the processor-visible I/O operations.
Note: This is a runtime protocol and can be used by runtime drivers after ExitBootServices().
It is different from the PI 1.2 CPU I/O 2 Protocol, which is a boot services only protocol
and may not be used by runtime drivers after ExitBootServices().
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
CPU IO Protocol is defined in Framework of EFI CPU IO Protocol Spec
Version 0.9.
**/
#ifndef _CPUIO_H_
#define _CPUIO_H_
#include <Protocol/CpuIo2.h>
#define EFI_CPU_IO_PROTOCOL_GUID \
{ \
0xB0732526, 0x38C8, 0x4b40, {0x88, 0x77, 0x61, 0xC7, 0xB0, 0x6A, 0xAC, 0x45 } \
}
//
// Framework CPU IO protocol structure is the same as CPU IO 2 protocol defined in PI 1.2 spec.
// However, there is a significant different between the Framework CPU I/O
// Protocol and the PI 1.2 CPU I/O 2 Protocol. The Framework one is a runtime
// protocol, which means it can be used by runtime drivers after ExitBootServices().
// The PI one is not runtime safe, so it is a boot services only protocol and may
// not be used by runtime drivers after ExitBootServices().
//
typedef EFI_CPU_IO2_PROTOCOL EFI_CPU_IO_PROTOCOL;
extern EFI_GUID gEfiCpuIoProtocolGuid;
#endif

222
IntelFrameworkPkg/Include/Protocol/DataHub.h Normal file
View File

@ -0,0 +1,222 @@
/** @file
The data hub protocol is used both by agents wishing to log
data and those wishing to be made aware of all information that
has been logged. This protocol may only be called <= TPL_NOTIFY.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
The Data Hub Protocol is defined in Framework for EFI Data Hub Specification
Version 0.9.
**/
#ifndef __DATA_HUB_H__
#define __DATA_HUB_H__
#define EFI_DATA_HUB_PROTOCOL_GUID \
{ \
0xae80d021, 0x618e, 0x11d4, {0xbc, 0xd7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
}
//
// EFI generic Data Hub Header
//
// A Data Record is an EFI_DATA_RECORD_HEADER followed by RecordSize bytes of
// data. The format of the data is defined by the DataRecordGuid.
//
// If EFI_DATA_RECORD_HEADER is extended in the future, the Version number and HeaderSize must
// change.
//
// The logger is responcible for initializing:
// Version, HeaderSize, RecordSize, DataRecordGuid, DataRecordClass
//
// The Data Hub driver is responcible for initializing:
// LogTime and LogMonotonicCount.
//
#define EFI_DATA_RECORD_HEADER_VERSION 0x0100
typedef struct {
UINT16 Version;
UINT16 HeaderSize;
UINT32 RecordSize;
EFI_GUID DataRecordGuid;
EFI_GUID ProducerName;
UINT64 DataRecordClass;
EFI_TIME LogTime;
UINT64 LogMonotonicCount;
} EFI_DATA_RECORD_HEADER;
//
// Definition of DataRecordClass. These are used to filter out class types
// at a very high level. The DataRecordGuid still defines the format of
// the data. See the Data Hub Specification for rules on what can and can not be a
// new DataRecordClass
//
#define EFI_DATA_RECORD_CLASS_DEBUG 0x0000000000000001
#define EFI_DATA_RECORD_CLASS_ERROR 0x0000000000000002
#define EFI_DATA_RECORD_CLASS_DATA 0x0000000000000004
#define EFI_DATA_RECORD_CLASS_PROGRESS_CODE 0x0000000000000008
//
// Forward reference for pure ANSI compatability
//
typedef struct _EFI_DATA_HUB_PROTOCOL EFI_DATA_HUB_PROTOCOL;
/**
Logs a data record to the system event log.
@param This The EFI_DATA_HUB_PROTOCOL instance.
@param DataRecordGuid A GUID that indicates the format of the data passed into RawData.
@param ProducerName A GUID that indicates the identity of the caller to this API.
@param DataRecordClass This class indicates the generic type of the data record.
@param RawData The DataRecordGuid-defined data to be logged.
@param RawDataSize The size in bytes of RawData.
@retval EFI_SUCCESS Data was logged.
@retval EFI_OUT_OF_RESOURCES Data was not logged due to lack of system resources.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_DATA_HUB_LOG_DATA)(
IN EFI_DATA_HUB_PROTOCOL *This,
IN EFI_GUID *DataRecordGuid,
IN EFI_GUID *ProducerName,
IN UINT64 DataRecordClass,
IN VOID *RawData,
IN UINT32 RawDataSize
);
/**
Allows the system data log to be searched.
@param This The EFI_DATA_HUB_PROTOCOL instance.
@param MonotonicCount On input, it specifies the Record to return.
An input of zero means to return the first record,
as does an input of one.
@param FilterDriver If FilterDriver is not passed in a MonotonicCount
of zero, it means to return the first data record.
If FilterDriver is passed in, then a MonotonicCount
of zero means to return the first data not yet read
by FilterDriver.
@param Record Returns a dynamically allocated memory buffer with
a data record that matches MonotonicCount.
@retval EFI_SUCCESS Data was returned in Record.
@retval EFI_INVALID_PARAMETER FilterDriver was passed in but does not exist.
@retval EFI_NOT_FOUND MonotonicCount does not match any data record
in the system. If a MonotonicCount of zero was
passed in, then no data records exist in the system.
@retval EFI_OUT_OF_RESOURCES Record was not returned due to lack
of system resources.
@note Inconsistent with specification here:
In Framework for EFI Data Hub Specification, Version 0.9, This definition
is named as EFI_DATA_HUB_GET_NEXT_DATA_RECORD. The inconsistency is
maintained for backward compatibility.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_DATA_HUB_GET_NEXT_RECORD)(
IN EFI_DATA_HUB_PROTOCOL *This,
IN OUT UINT64 *MonotonicCount,
IN EFI_EVENT *FilterDriver OPTIONAL,
OUT EFI_DATA_RECORD_HEADER **Record
);
/**
Registers an event to be signaled every time a data record is logged in the system.
@param This The EFI_DATA_HUB_PROTOCOL instance.
@param FilterEvent The EFI_EVENT to signal whenever data that matches
FilterClass is logged in the system.
@param FilterTpl The maximum EFI_TPL at which FilterEvent can be
signaled. It is strongly recommended that you use
the lowest EFI_TPL possible.
@param FilterClass FilterEvent will be signaled whenever a bit
in EFI_DATA_RECORD_HEADER.DataRecordClass is also
set in FilterClass. If FilterClass is zero, no
class-based filtering will be performed.
@param FilterDataRecordGuid FilterEvent will be signaled whenever
FilterDataRecordGuid matches
EFI_DATA_RECORD_HEADER.DataRecordGuid.
If FilterDataRecordGuid is NULL, then no GUID-based
filtering will be performed.
@retval EFI_SUCCESS The filter driver event was registered
@retval EFI_ALREADY_STARTED FilterEvent was previously registered and cannot
be registered again.
@retval EFI_OUT_OF_RESOURCES The filter driver event was not registered
due to lack of system resources.
@note Inconsistent with specification here:
In Framework for EFI Data Hub Specification, Version 0.9, This definition
is named as EFI_DATA_HUB_REGISTER_DATA_FILTER_DRIVER. The inconsistency
is maintained for backward compatibility.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_DATA_HUB_REGISTER_FILTER_DRIVER)(
IN EFI_DATA_HUB_PROTOCOL *This,
IN EFI_EVENT FilterEvent,
IN EFI_TPL FilterTpl,
IN UINT64 FilterClass,
IN EFI_GUID *FilterDataRecordGuid OPTIONAL
);
/**
Stops a filter driver from being notified when data records are logged.
@param This The EFI_DATA_HUB_PROTOCOL instance.
@param FilterEvent The EFI_EVENT to remove from the list of events to be
signaled every time errors are logged.
@retval EFI_SUCCESS The filter driver represented by FilterEvent was shut off.
@retval EFI_NOT_FOUND FilterEvent did not exist.
@note Inconsistent with specification here:
In Framework for EFI Data Hub Specification, Version 0.9, This definition
is named as EFI_DATA_HUB_UNREGISTER_DATA_FILTER_DRIVER. The inconsistency
is maintained for backward compatibility.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_DATA_HUB_UNREGISTER_FILTER_DRIVER)(
IN EFI_DATA_HUB_PROTOCOL *This,
IN EFI_EVENT FilterEvent
);
/**
This protocol is used to log information and register filter drivers
to receive data records.
**/
struct _EFI_DATA_HUB_PROTOCOL {
///
/// Logs a data record.
///
EFI_DATA_HUB_LOG_DATA LogData;
///
/// Gets a data record. Used both to view the memory-based log and to
/// get information about which data records have been consumed by a filter driver.
///
EFI_DATA_HUB_GET_NEXT_RECORD GetNextRecord;
///
/// Allows the registration of an EFI event to act as a filter driver for all data records that are logged.
///
EFI_DATA_HUB_REGISTER_FILTER_DRIVER RegisterFilterDriver;
///
/// Used to remove a filter driver that was added with RegisterFilterDriver().
///
EFI_DATA_HUB_UNREGISTER_FILTER_DRIVER UnregisterFilterDriver;
};
extern EFI_GUID gEfiDataHubProtocolGuid;
#endif

346
IntelFrameworkPkg/Include/Protocol/FirmwareVolume.h Normal file
View File

@ -0,0 +1,346 @@
/** @file
This file declares the Firmware Volume Protocol.
The Firmware Volume Protocol provides file-level access to the firmware volume.
Each firmware volume driver must produce an instance of the Firmware Volume
Protocol if the firmware volume is to be visible to the system. The Firmware
Volume Protocol also provides mechanisms for determining and modifying some
attributes of the firmware volume.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in Firmware Volume specification.
Version 0.9.
**/
#ifndef _FIRMWARE_VOLUME_H_
#define _FIRMWARE_VOLUME_H_
//
// Firmware Volume Protocol GUID definition
//
#define EFI_FIRMWARE_VOLUME_PROTOCOL_GUID \
{ \
0x389F751F, 0x1838, 0x4388, {0x83, 0x90, 0xCD, 0x81, 0x54, 0xBD, 0x27, 0xF8 } \
}
#define FV_DEVICE_SIGNATURE SIGNATURE_32 ('_', 'F', 'V', '_')
typedef struct _EFI_FIRMWARE_VOLUME_PROTOCOL EFI_FIRMWARE_VOLUME_PROTOCOL;
//
// FRAMEWORK_EFI_FV_ATTRIBUTES bit definitions
//
typedef UINT64 FRAMEWORK_EFI_FV_ATTRIBUTES;
//
// ************************************************************
// FRAMEWORK_EFI_FV_ATTRIBUTES bit definitions
// ************************************************************
//
#define EFI_FV_READ_DISABLE_CAP 0x0000000000000001ULL
#define EFI_FV_READ_ENABLE_CAP 0x0000000000000002ULL
#define EFI_FV_READ_STATUS 0x0000000000000004ULL
#define EFI_FV_WRITE_DISABLE_CAP 0x0000000000000008ULL
#define EFI_FV_WRITE_ENABLE_CAP 0x0000000000000010ULL
#define EFI_FV_WRITE_STATUS 0x0000000000000020ULL
#define EFI_FV_LOCK_CAP 0x0000000000000040ULL
#define EFI_FV_LOCK_STATUS 0x0000000000000080ULL
#define EFI_FV_WRITE_POLICY_RELIABLE 0x0000000000000100ULL
#define EFI_FV_ALIGNMENT_CAP 0x0000000000008000ULL
#define EFI_FV_ALIGNMENT_2 0x0000000000010000ULL
#define EFI_FV_ALIGNMENT_4 0x0000000000020000ULL
#define EFI_FV_ALIGNMENT_8 0x0000000000040000ULL
#define EFI_FV_ALIGNMENT_16 0x0000000000080000ULL
#define EFI_FV_ALIGNMENT_32 0x0000000000100000ULL
#define EFI_FV_ALIGNMENT_64 0x0000000000200000ULL
#define EFI_FV_ALIGNMENT_128 0x0000000000400000ULL
#define EFI_FV_ALIGNMENT_256 0x0000000000800000ULL
#define EFI_FV_ALIGNMENT_512 0x0000000001000000ULL
#define EFI_FV_ALIGNMENT_1K 0x0000000002000000ULL
#define EFI_FV_ALIGNMENT_2K 0x0000000004000000ULL
#define EFI_FV_ALIGNMENT_4K 0x0000000008000000ULL
#define EFI_FV_ALIGNMENT_8K 0x0000000010000000ULL
#define EFI_FV_ALIGNMENT_16K 0x0000000020000000ULL
#define EFI_FV_ALIGNMENT_32K 0x0000000040000000ULL
#define EFI_FV_ALIGNMENT_64K 0x0000000080000000ULL
//
// Protocol API definitions
//
/**
Retrieves attributes, insures positive polarity of attribute bits, and returns
resulting attributes in an output parameter.
@param This Indicates the EFI_FIRMWARE_VOLUME_PROTOCOL instance.
@param Attributes Output buffer containing attributes.
@retval EFI_SUCCESS The firmware volume attributes were returned.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FV_GET_ATTRIBUTES)(
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
OUT FRAMEWORK_EFI_FV_ATTRIBUTES *Attributes
);
/**
Sets volume attributes
@param This Indicates the EFI_FIRMWARE_VOLUME_PROTOCOL instance.
@param Attributes On input, Attributes is a pointer to an
EFI_FV_ATTRIBUTES containing the desired firmware
volume settings. On successful return, it contains
the new settings of the firmware volume. On
unsuccessful return, Attributes is not modified
and the firmware volume settings are not changed.
@retval EFI_INVALID_PARAMETER A bit in Attributes was invalid.
@retval EFI_SUCCESS The requested firmware volume attributes were set
and the resulting EFI_FV_ATTRIBUTES is returned in
Attributes.
@retval EFI_ACCESS_DENIED The Device is locked and does not permit modification.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FV_SET_ATTRIBUTES)(
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN OUT FRAMEWORK_EFI_FV_ATTRIBUTES *Attributes
);
/**
Read the requested file (NameGuid) or file information from the firmware volume
and returns data in Buffer.
@param This The EFI_FIRMWARE_VOLUME_PROTOCOL instance.
@param NameGuid The pointer to EFI_GUID, which is the filename of
the file to read.
@param Buffer The pointer to pointer to buffer in which contents of file are returned.
<br>
If Buffer is NULL, only type, attributes, and size
are returned as there is no output buffer.
<br>
If Buffer != NULL and *Buffer == NULL, the output
buffer is allocated from BS pool by ReadFile.
<br>
If Buffer != NULL and *Buffer != NULL, the output
buffer has been allocated by the caller and is being
passed in.
@param BufferSize On input: The buffer size. On output: The size
required to complete the read.
@param FoundType The pointer to the type of the file whose data
is returned.
@param FileAttributes The pointer to attributes of the file whose data
is returned.
@param AuthenticationStatus The pointer to the authentication status of the data.
@retval EFI_SUCCESS The call completed successfully.
@retval EFI_WARN_BUFFER_TOO_SMALL The buffer is too small to contain the requested output.
The buffer filled, and the output is truncated.
@retval EFI_NOT_FOUND NameGuid was not found in the firmware volume.
@retval EFI_DEVICE_ERROR A hardware error occurred when attempting to
access the firmware volume.
@retval EFI_ACCESS_DENIED The firmware volume is configured to disallow reads.
@retval EFI_OUT_OF_RESOURCES An allocation failure occurred.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FV_READ_FILE)(
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN EFI_GUID *NameGuid,
IN OUT VOID **Buffer,
IN OUT UINTN *BufferSize,
OUT EFI_FV_FILETYPE *FoundType,
OUT EFI_FV_FILE_ATTRIBUTES *FileAttributes,
OUT UINT32 *AuthenticationStatus
);
/**
Read the requested section from the specified file and returns data in Buffer.
@param This Indicates the EFI_FIRMWARE_VOLUME_PROTOCOL instance.
@param NameGuid Filename identifying the file from which to read.
@param SectionType The section type to retrieve.
@param SectionInstance The instance of SectionType to retrieve.
@param Buffer Pointer to pointer to buffer in which contents of
a file are returned.
<br>
If Buffer is NULL, only type, attributes, and size
are returned as there is no output buffer.
<br>
If Buffer != NULL and *Buffer == NULL, the output
buffer is allocated from BS pool by ReadFile.
<br>
If Buffer != NULL and *Buffer != NULL, the output
buffer has been allocated by the caller and is being
passed in.
@param BufferSize The pointer to the buffer size passed in, and on
output the size required to complete the read.
@param AuthenticationStatus The pointer to the authentication status of the data.
@retval EFI_SUCCESS The call completed successfully.
@retval EFI_WARN_BUFFER_TOO_SMALL The buffer is too small to contain the requested output.
The buffer is filled and the output is truncated.
@retval EFI_OUT_OF_RESOURCES An allocation failure occurred.
@retval EFI_NOT_FOUND The name was not found in the firmware volume.
@retval EFI_DEVICE_ERROR A hardware error occurred when attempting to
access the firmware volume.
@retval EFI_ACCESS_DENIED The firmware volume is configured to disallow reads.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FV_READ_SECTION)(
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN EFI_GUID *NameGuid,
IN EFI_SECTION_TYPE SectionType,
IN UINTN SectionInstance,
IN OUT VOID **Buffer,
IN OUT UINTN *BufferSize,
OUT UINT32 *AuthenticationStatus
);
typedef UINT32 FRAMEWORK_EFI_FV_WRITE_POLICY;
#define FRAMEWORK_EFI_FV_UNRELIABLE_WRITE 0x00000000
#define FRAMEWORK_EFI_FV_RELIABLE_WRITE 0x00000001
typedef struct {
EFI_GUID *NameGuid;
EFI_FV_FILETYPE Type;
EFI_FV_FILE_ATTRIBUTES FileAttributes;
VOID *Buffer;
UINT32 BufferSize;
} FRAMEWORK_EFI_FV_WRITE_FILE_DATA;
/**
Write the supplied file (NameGuid) to the FV.
@param This Indicates the EFI_FIRMWARE_VOLUME_PROTOCOL instance.
@param NumberOfFiles Indicates the number of file records pointed to
by FileData.
@param WritePolicy Indicates the level of reliability of the write
with respect to things like power failure events.
@param FileData A pointer to an array of EFI_FV_WRITE_FILE_DATA
structures. Each element in the array indicates
a file to write, and there are NumberOfFiles
elements in the input array.
@retval EFI_SUCCESS The write completed successfully.
@retval EFI_OUT_OF_RESOURCES The firmware volume does not have enough free
space to store file(s).
@retval EFI_DEVICE_ERROR A hardware error occurred when attempting to
access the firmware volume.
@retval EFI_WRITE_PROTECTED The firmware volume is configured to disallow writes.
@retval EFI_NOT_FOUND A delete was requested, but the requested file was
not found in the firmware volume.
@retval EFI_INVALID_PARAMETER A delete was requested with a multiple file write.
An unsupported WritePolicy was requested.
An unknown file type was specified.
A file system specific error has occurred.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FV_WRITE_FILE)(
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN UINT32 NumberOfFiles,
IN FRAMEWORK_EFI_FV_WRITE_POLICY WritePolicy,
IN FRAMEWORK_EFI_FV_WRITE_FILE_DATA *FileData
);
/**
Given the input key, search for the next matching file in the volume.
@param This Indicates the EFI_FIRMWARE_VOLUME_PROTOCOL instance.
@param Key Pointer to a caller allocated buffer that contains
an implementation-specific key that is used to track
where to begin searching on successive calls.
@param FileType The pointer to the file type to filter for.
@param NameGuid The pointer to Guid filename of the file found.
@param Attributes The pointer to Attributes of the file found.
@param Size The pointer to Size in bytes of the file found.
@retval EFI_SUCCESS The output parameters are filled with data obtained from
the first matching file that was found.
@retval EFI_NOT_FOUND No files of type FileType were found.
@retval EFI_DEVICE_ERROR A hardware error occurred when attempting to access
the firmware volume.
@retval EFI_ACCESS_DENIED The firmware volume is configured to disallow reads.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FV_GET_NEXT_FILE)(
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN OUT VOID *Key,
IN OUT EFI_FV_FILETYPE *FileType,
OUT EFI_GUID *NameGuid,
OUT EFI_FV_FILE_ATTRIBUTES *Attributes,
OUT UINTN *Size
);
//
// Protocol interface structure
//
struct _EFI_FIRMWARE_VOLUME_PROTOCOL {
///
/// Retrieves volume capabilities and current settings.
///
FRAMEWORK_EFI_FV_GET_ATTRIBUTES GetVolumeAttributes;
///
/// Modifies the current settings of the firmware volume.
///
FRAMEWORK_EFI_FV_SET_ATTRIBUTES SetVolumeAttributes;
///
/// Reads an entire file from the firmware volume.
///
FRAMEWORK_EFI_FV_READ_FILE ReadFile;
///
/// Reads a single section from a file into a buffer.
///
FRAMEWORK_EFI_FV_READ_SECTION ReadSection;
///
/// Writes an entire file into the firmware volume.
///
FRAMEWORK_EFI_FV_WRITE_FILE WriteFile;
///
/// Provides service to allow searching the firmware volume.
///
FRAMEWORK_EFI_FV_GET_NEXT_FILE GetNextFile;
///
/// Data field that indicates the size in bytes of the Key input buffer for
/// the GetNextFile() API.
///
UINT32 KeySize;
///
/// Handle of the parent firmware volume.
///
EFI_HANDLE ParentHandle;
};
extern EFI_GUID gEfiFirmwareVolumeProtocolGuid;
#endif

353
IntelFrameworkPkg/Include/Protocol/FrameworkFirmwareVolumeBlock.h Normal file
View File

@ -0,0 +1,353 @@
/** @file
This file provides control over block-oriented firmware devices.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in framework spec: Firmware Volume Block Specification.
**/
#ifndef __FRAMEWORK_FIRMWARE_VOLUME_BLOCK_H__
#define __FRAMEWORK_FIRMWARE_VOLUME_BLOCK_H__
#define FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID \
{ 0xDE28BC59, 0x6228, 0x41BD, {0xBD, 0xF6, 0xA3, 0xB9, 0xAD,0xB5, 0x8D, 0xA1 } }
typedef struct _FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL;
///
/// The type of EFI FVB attribute per the Framework specification.
///
typedef UINT32 EFI_FVB_ATTRIBUTES;
/**
The GetAttributes() function retrieves the attributes and
current settings of the block.
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL instance.
@param Attributes Pointer to EFI_FVB_ATTRIBUTES in which the
attributes and current settings are
returned.
@retval EFI_SUCCESS The firmware volume attributes were
returned.
**/
typedef
EFI_STATUS
(EFIAPI * FRAMEWORK_EFI_FVB_GET_ATTRIBUTES)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_FVB_ATTRIBUTES *Attributes
);
/**
The SetAttributes() function sets configurable firmware volume
attributes and returns the new settings of the firmware volume.
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL instance.
@param Attributes On input, Attributes is a pointer to
EFI_FVB_ATTRIBUTES that contains the
desired firmware volume settings. On
successful return, it contains the new
settings of the firmware volume.
@retval EFI_SUCCESS The firmware volume attributes were returned.
@retval EFI_INVALID_PARAMETER The attributes requested are in
conflict with the capabilities
as declared in the firmware
volume header.
**/
typedef
EFI_STATUS
(EFIAPI * FRAMEWORK_EFI_FVB_SET_ATTRIBUTES)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN OUT EFI_FVB_ATTRIBUTES *Attributes
);
/**
The GetPhysicalAddress() function retrieves the base address of
a memory-mapped firmware volume. This function should be called
only for memory-mapped firmware volumes.
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL instance.
@param Address Pointer to a caller-allocated
EFI_PHYSICAL_ADDRESS that, on successful
return from GetPhysicalAddress(), contains the
base address of the firmware volume.
@retval EFI_SUCCESS The firmware volume base address is returned.
@retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped.
**/
typedef
EFI_STATUS
(EFIAPI * FRAMEWORK_EFI_FVB_GET_PHYSICAL_ADDRESS)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_PHYSICAL_ADDRESS *Address
);
/**
The GetBlockSize() function retrieves the size of the requested
block. It also returns the number of additional blocks with
the identical size. The GetBlockSize() function is used to
retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL instance.
@param Lba Indicates the block for which to return the size.
@param BlockSize The pointer to a caller-allocated UINTN in which
the size of the block is returned.
@param NumberOfBlocks The pointer to a caller-allocated UINTN in
which the number of consecutive blocks,
starting with Lba, is returned. All
blocks in this range have a size of
BlockSize.
@retval EFI_SUCCESS The firmware volume base address was returned.
@retval EFI_INVALID_PARAMETER The requested LBA is out of range.
**/
typedef
EFI_STATUS
(EFIAPI * FRAMEWORK_EFI_FVB_GET_BLOCK_SIZE)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
OUT UINTN *BlockSize,
OUT UINTN *NumberOfBlocks
);
/**
Reads the specified number of bytes into a buffer from the specified block.
The Read() function reads the requested number of bytes from the
requested block and stores them in the provided buffer.
Implementations should be mindful that the firmware volume
might be in the ReadDisabled state. If it is in this state,
the Read() function must return the status code
EFI_ACCESS_DENIED without modifying the contents of the
buffer. The Read() function must also prevent spanning block
boundaries. If a read is requested that would span a block
boundary, the read must read up to the boundary but not
beyond. The output parameter NumBytes must be set to correctly
indicate the number of bytes actually read. The caller must be
aware that a read may be partially completed.
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL instance.
@param Lba The starting logical block index
from which to read.
@param Offset Offset into the block at which to begin reading.
@param NumBytes The pointer to a UINTN. At entry, *NumBytes
contains the total size of the buffer. At
exit, *NumBytes contains the total number of
bytes read.
@param Buffer The pointer to a caller-allocated buffer that will
be used to hold the data that is read.
@retval EFI_SUCCESS The firmware volume was read successfully
and contents are in Buffer.
@retval EFI_BAD_BUFFER_SIZE A read was attempted across an LBA
boundary. On output, NumBytes
contains the total number of bytes
returned in Buffer.
@retval EFI_ACCESS_DENIED The firmware volume is in the
ReadDisabled state.
@retval EFI_DEVICE_ERROR The block device is not
functioning correctly and could
not be read.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_FVB_READ)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
IN OUT UINT8 *Buffer
);
/**
Writes the specified number of bytes from the input buffer to the block.
The Write() function writes the specified number of bytes from
the provided buffer to the specified block and offset. If the
firmware volume is sticky write, the caller must ensure that
all the bits of the specified range to write are in the
EFI_FVB_ERASE_POLARITY state before calling the Write()
function, or else the result will be unpredictable. This
unpredictability arises because, for a sticky-write firmware
volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY
state but cannot flip it back again. In general, before
calling the Write() function, the caller should call the
EraseBlocks() function first to erase the specified block to
write. A block erase cycle will transition bits from the
(NOT)EFI_FVB_ERASE_POLARITY state back to the
EFI_FVB_ERASE_POLARITY state. Implementors should note
that the firmware volume might be in the WriteDisabled
state. If it is in this state, the Write() function must
return the status code EFI_ACCESS_DENIED without modifying the
contents of the firmware volume. The Write() function must
also prevent spanning block boundaries. If a write is
requested that spans a block boundary, the write must store up
to the boundary but not beyond. The output parameter NumBytes
must be set to correctly indicate the number of bytes actually
written. The caller must be aware that a write may be
partially completed. All writes, partial or otherwise, must be
fully flushed to the hardware before the Write() service
returns.
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL instance.
@param Lba The starting logical block index to write to.
@param Offset Offset into the block at which to begin writing.
@param NumBytes The pointer to a UINTN. Input: the total size of the buffer.
Output: the total number of bytes actually written.
@param Buffer The pointer to a caller-allocated buffer that
contains the source for the write.
@retval EFI_SUCCESS The firmware volume was written successfully.
@retval EFI_BAD_BUFFER_SIZE The write was attempted across an
LBA boundary. On output, NumBytes
contains the total number of bytes
actually written.
@retval EFI_ACCESS_DENIED The firmware volume is in the
WriteDisabled state.
@retval EFI_DEVICE_ERROR The block device is malfunctioning
and could not be written.
**/
typedef
EFI_STATUS
(EFIAPI * FRAMEWORK_EFI_FVB_WRITE)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
);
///
/// EFI_LBA_LIST_TERMINATOR.
///
#define FRAMEWORK_EFI_LBA_LIST_TERMINATOR 0xFFFFFFFFFFFFFFFFULL
/**
Erases and initializes a firmware volume block.
The EraseBlocks() function erases one or more blocks as denoted
by the variable argument list. The entire parameter list of
blocks must be verified before erasing any blocks. If a block is
requested that does not exist within the associated firmware
volume (it has a larger index than the last block of the
firmware volume), the EraseBlocks() function must return the
status code EFI_INVALID_PARAMETER without modifying the contents
of the firmware volume. Implementors should note that
the firmware volume might be in the WriteDisabled state. If it
is in this state, the EraseBlocks() function must return the
status code EFI_ACCESS_DENIED without modifying the contents of
the firmware volume. All calls to EraseBlocks() must be fully
flushed to the hardware before the EraseBlocks() service
returns.
@param This Indicates the FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL
instance.
@param ... A list of tuples.
Each tuple describes a range of LBAs to erase
and consists of the following:
- An EFI_LBA that indicates the starting LBA
- A UINTN that indicates the number of blocks to
erase
The list is terminated with an
EFI_LBA_LIST_TERMINATOR. For example, the
following indicates that two ranges of blocks
(5-7 and 10-11) are to be erased: EraseBlocks
(This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR);
@retval EFI_SUCCESS The erase request successfully
completed.
@retval EFI_ACCESS_DENIED The firmware volume is in the
WriteDisabled state.
@retval EFI_DEVICE_ERROR The block device is not functioning
correctly and could not be written.
The firmware device may have been
partially erased.
@retval EFI_INVALID_PARAMETER One or more of the LBAs listed
in the variable argument list do
not exist in the firmware volume.
**/
typedef
EFI_STATUS
(EFIAPI * FRAMEWORK_EFI_FVB_ERASE_BLOCKS)(
IN FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
...
);
///
/// The Firmware Volume Block Protocol is the low-level interface
/// to a firmware volume. File-level access to a firmware volume
/// should not be done using the Firmware Volume Block Protocol.
/// Normal access to a firmware volume must use the Firmware
/// Volume Protocol. Typically, only the file system driver that
/// produces the Firmware Volume Protocol will bind to the
/// Firmware Volume Block Protocol.
///
struct _FRAMEWORK_EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL {
FRAMEWORK_EFI_FVB_GET_ATTRIBUTES GetAttributes;
FRAMEWORK_EFI_FVB_SET_ATTRIBUTES SetAttributes;
FRAMEWORK_EFI_FVB_GET_PHYSICAL_ADDRESS GetPhysicalAddress;
FRAMEWORK_EFI_FVB_GET_BLOCK_SIZE GetBlockSize;
FRAMEWORK_EFI_FVB_READ Read;
FRAMEWORK_EFI_FVB_WRITE Write;
FRAMEWORK_EFI_FVB_ERASE_BLOCKS EraseBlocks;
///
/// The handle of the parent firmware volume.
///
EFI_HANDLE ParentHandle;
};
extern EFI_GUID gFramerworkEfiFirmwareVolumeBlockProtocolGuid;
#endif

175
IntelFrameworkPkg/Include/Protocol/FrameworkFormBrowser.h Normal file
View File

@ -0,0 +1,175 @@
/** @file
The EFI_FORM_BROWSER_PROTOCOL is the interface to the EFI
Configuration Driver. This interface enables the caller to direct the
configuration driver to use either the HII database or the passed-in
packet of data. This will also allow the caller to post messages
into the configuration drivers internal mailbox.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: FrameworkFormBrowser.h
@par Revision Reference:
This protocol is defined in HII spec 0.92.
**/
#ifndef __FRAMEWORK_FORM_BROWSER_H__
#define __FRAMEWORK_FORM_BROWSER_H__
#include <Protocol/FrameworkHii.h>
#define EFI_FORM_BROWSER_PROTOCOL_GUID \
{ \
0xe5a1333e, 0xe1b4, 0x4d55, {0xce, 0xeb, 0x35, 0xc3, 0xef, 0x13, 0x34, 0x43 } \
}
#define EFI_FORM_BROWSER_COMPATIBILITY_PROTOCOL_GUID \
{ \
0xfb7c852, 0xadca, 0x4853, { 0x8d, 0xf, 0xfb, 0xa7, 0x1b, 0x1c, 0xe1, 0x1a } \
}
typedef struct _EFI_FORM_BROWSER_PROTOCOL EFI_FORM_BROWSER_PROTOCOL;
typedef struct {
UINT32 Length;
UINT16 Type;
UINT8 Data[1];
} EFI_HII_PACKET;
typedef struct {
EFI_HII_IFR_PACK *IfrData;
EFI_HII_STRING_PACK *StringData;
} EFI_IFR_PACKET;
typedef struct {
UINTN LeftColumn;
UINTN RightColumn;
UINTN TopRow;
UINTN BottomRow;
} FRAMEWORK_EFI_SCREEN_DESCRIPTOR;
/**
Provides direction to the configuration driver whether to use the HII
database or a passed-in set of data. This function also establishes a
pointer to the calling driver's callback interface.
@param This A pointer to the EFI_FORM_BROWSER_PROTOCOL instance.
@param UseDatabase Determines whether the HII database is to be
used to gather information. If the value is FALSE,
the configuration driver will get the information
provided in the passed-in Packet parameters.
@param Handle A pointer to an array of HII handles to display.
This value should correspond to the value of the
HII form package that is required to be displayed.
@param HandleCount The number of handles in the array specified by Handle.
@param Packet A pointer to a set of data containing pointers to IFR
and/or string data.
@param CallbackHandle The handle to the driver's callback interface.
This parameter is used only when the UseDatabase
parameter is FALSE and an application wants to
register a callback with the browser.
@param NvMapOverride This buffer is used only when there is no NV variable
to define the current settings and the caller needs
to provide to the browser the current settings for
the "fake" NV variable.
@param ScreenDimensions Allows the browser to be called so that it occupies
a portion of the physical screen instead of dynamically
determining the screen dimensions.
@param ResetRequired This BOOLEAN value denotes whether a reset is required
based on the data that might have been changed.
The ResetRequired parameter is primarily applicable
for configuration applications, and is an
optional parameter.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_NOT_FOUND The variable was not found.
@retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the result.
DataSize has been updated with the size needed to
complete the request.
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
@retval EFI_DEVICE_ERROR The variable could not be saved due to a hardware failure.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SEND_FORM)(
IN EFI_FORM_BROWSER_PROTOCOL *This,
IN BOOLEAN UseDatabase,
IN FRAMEWORK_EFI_HII_HANDLE *Handle,
IN UINTN HandleCount,
IN EFI_IFR_PACKET *Packet, OPTIONAL
IN EFI_HANDLE CallbackHandle, OPTIONAL
IN UINT8 *NvMapOverride, OPTIONAL
IN FRAMEWORK_EFI_SCREEN_DESCRIPTOR *ScreenDimensions, OPTIONAL
OUT BOOLEAN *ResetRequired OPTIONAL
);
/**
Routine used to abstract a generic dialog interface and return the selected
key or string.
@param NumberOfLines The number of lines for the dialog box.
@param HotKey Defines whether a single character is parsed (TRUE)
and returned in KeyValue, or if a string is returned
in StringBuffer.
@param MaximumStringSize The maximum size in bytes of a typed-in string.
Because each character is a CHAR16, the minimum
string returned is two bytes.
@param StringBuffer The passed-in pointer to the buffer that will hold
the typed in string if HotKey is FALSE.
@param KeyValue The EFI_INPUT_KEY value returned if HotKey is TRUE.
@param String The pointer to the first string in the list of strings
that comprise the dialog box.
@param ... A series of NumberOfLines text strings that will be used
to construct the dialog box.
@retval EFI_SUCCESS The dialog was displayed and user interaction was received.
@retval EFI_DEVICE_ERROR The user typed in an ESC character to exit the routine.
@retval EFI_INVALID_PARAMETER One of the parameters was invalid
**/
typedef
EFI_STATUS
(EFIAPI *EFI_CREATE_POP_UP)(
IN UINTN NumberOfLines,
IN BOOLEAN HotKey,
IN UINTN MaximumStringSize,
OUT CHAR16 *StringBuffer,
OUT EFI_INPUT_KEY *KeyValue,
IN CHAR16 *String,
...
);
/**
The EFI_FORM_BROWSER_PROTOCOL is the interface to call for drivers to
leverage the EFI configuration driver interface.
**/
struct _EFI_FORM_BROWSER_PROTOCOL {
///
/// Provides direction to the configuration driver whether to use the HII
/// database or to use a passed-in set of data. This function also establishes
/// a pointer to the calling driver's callback interface.
///
EFI_SEND_FORM SendForm;
///
/// Routine used to abstract a generic dialog interface and return the
/// selected key or string.
///
EFI_CREATE_POP_UP CreatePopUp;
};
extern EFI_GUID gEfiFormBrowserProtocolGuid;
extern EFI_GUID gEfiFormBrowserCompatibilityProtocolGuid;
#endif

222
IntelFrameworkPkg/Include/Protocol/FrameworkFormCallback.h Normal file
View File

@ -0,0 +1,222 @@
/** @file
The EFI_FORM_CALLBACK_PROTOCOL is the defined interface for access to custom
NV storage devices and for communication of user selections in a more
interactive environment. This protocol should be published by hardware
specific drivers that want to export access to custom hardware storage or
publish IFR that need to call back the original driver.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in HII spec 0.92.
**/
#ifndef __FRAMEWORK_FORM_CALLBACK_H__
#define __FRAMEWORK_FORM_CALLBACK_H__
#include <Protocol/FrameworkHii.h>
#include <Protocol/FrameworkFormBrowser.h>
#define EFI_FORM_CALLBACK_PROTOCOL_GUID \
{ \
0xf3e4543d, 0xcf35, 0x6cef, {0x35, 0xc4, 0x4f, 0xe6, 0x34, 0x4d, 0xfc, 0x54 } \
}
//
// Forward reference for pure ANSI compatability
//
typedef struct _EFI_FORM_CALLBACK_PROTOCOL EFI_FORM_CALLBACK_PROTOCOL;
///
/// Inconsistent with specification here:
/// RESET_REQUIRED, EXIT_REQUIRED, SAVE_REQUIRED, NV_CHANGED and NV_NOT_CHANGED are not
/// defined in HII specification. These Flags of EFI_IFR_DATA_ENTRY should be defined
/// to describe the standard behavior of the browser after the callback.
///
/// If this flag is set, the browser will exit and reset after processing callback results.
///
#define RESET_REQUIRED 1
///
/// If this flag is set, the browser will exit after processing callback results.
///
#define EXIT_REQUIRED 2
///
/// If this flag is set, the browser will save the NV data after processing callback results.
///
#define SAVE_REQUIRED 4
///
/// If this flag is set, the browser will turn the NV flag on after processing callback results.
///
#define NV_CHANGED 8
///
/// If this flag is set, the browser will turn the NV flag off after processing callback results.
///
#define NV_NOT_CHANGED 16
#pragma pack(1)
typedef struct {
UINT8 OpCode; ///< Likely a string, numeric, or one-of
UINT8 Length; ///< Length of the EFI_IFR_DATA_ENTRY packet.
UINT16 Flags; ///< Flags settings to determine what behavior is desired from the browser after the callback.
VOID *Data; ///< The data in the form based on the op-code type. This is not a pointer to the data; the data follows immediately.
///
/// If the OpCode is a OneOf or Numeric type - Data is a UINT16 value.
/// If the OpCode is a String type - Data is a CHAR16[x] type.
/// If the OpCode is a Checkbox type - Data is a UINT8 value.
/// If the OpCode is a NV Access type - Data is a EFI_IFR_NV_DATA structure.
///
} EFI_IFR_DATA_ENTRY;
typedef struct {
VOID *NvRamMap; ///< If the flag of the op-code specified retrieval of a copy of the NVRAM map.
//
// this is a pointer to a buffer copy
//
UINT32 EntryCount; ///< Number of EFI_IFR_DATA_ENTRY entries.
//
// EFI_IFR_DATA_ENTRY Data[1]; // The in-line Data entries.
//
} EFI_IFR_DATA_ARRAY;
typedef union {
EFI_IFR_DATA_ARRAY DataArray; ///< Primarily used by those that call back to their drivers and use HII as a repository.
EFI_IFR_PACKET DataPacket; ///< Primarily used by those that do not use HII as a repository.
CHAR16 String[1]; ///< If returning an error - fill the string with null-terminated contents.
} EFI_HII_CALLBACK_PACKET;
typedef struct {
FRAMEWORK_EFI_IFR_OP_HEADER Header;
UINT16 QuestionId; ///< Offset into the map.
UINT8 StorageWidth; ///< Width of the value.
//
// CHAR8 Data[1]; // The Data itself
//
} EFI_IFR_NV_DATA;
#pragma pack()
//
// The following types are currently defined:
//
/**
Returns the value of a variable.
@param This A pointer to the EFI_FORM_CALLBACK_PROTOCOL instance.
@param VariableName A NULL-terminated Unicode string that is the
name of the vendor's variable.
@param VendorGuid A unique identifier for the vendor.
@param Attributes If not NULL, a pointer to the memory location to
return the attribute's bit-mask for the variable.
@param DataSize The size in bytes of the Buffer. A size of zero causes
the variable to be deleted.
@param Buffer The buffer to return the contents of the variable.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_NOT_FOUND The variable was not found.
@retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the result.
DataSize has been updated with the size needed to complete the request.
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
@retval EFI_DEVICE_ERROR The variable could not be saved due to a hardware failure.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_NV_READ)(
IN EFI_FORM_CALLBACK_PROTOCOL *This,
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Buffer
);
/**
Sets the value of a variable.
@param This A pointer to the EFI_FORM_CALLBACK_PROTOCOL instance.
@param VariableName A NULL-terminated Unicode string that is the
name of the vendor's variable. Each VariableName
is unique for each VendorGuid.
@param VendorGuid A unique identifier for the vendor.
@param Attributes Attributes bit-mask to set for the variable.
Inconsistent with specification here:
Attributes data type has been changed from
UINT32 * to UINT32, because the input parameter is
not necessary to use a pointer date type.
@param DataSize The size in bytes of the Buffer. A size of zero causes
the variable to be deleted.
@param Buffer The buffer containing the contents of the variable.
@param ResetRequired Returns a value from the driver that abstracts this
information and will enable a system to know if a
system reset is required to achieve the configuration
changes being enabled through this function.
@retval EFI_SUCCESS The firmware has successfully stored the variable and
its data as defined by the Attributes.
@retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold
the variable and its data.
@retval EFI_INVALID_PARAMETER An invalid combination of Attributes bits
was supplied, or the DataSize exceeds the maximum allowed.
@retval EFI_DEVICE_ERROR The variable could not be saved due to a hardware failure.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_NV_WRITE)(
IN EFI_FORM_CALLBACK_PROTOCOL *This,
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Buffer,
OUT BOOLEAN *ResetRequired
);
/**
This function is called to provide results data to the driver.
@param This A pointer to the EFI_FORM_CALLBACK_PROTOCOL instance.
@param KeyValue A unique value which is sent to the original exporting
driver so that it can identify the type of data
to expect. The format of the data tends to vary based
on the opcode that generated the callback.
@param Data A pointer to the data being sent to the original exporting driver.
@param Packet A pointer to a packet of information that a driver passes
back to the browser.
@return Status Code
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FORM_CALLBACK)(
IN EFI_FORM_CALLBACK_PROTOCOL *This,
IN UINT16 KeyValue,
IN EFI_IFR_DATA_ARRAY *Data,
OUT EFI_HII_CALLBACK_PACKET **Packet
);
/**
The EFI_FORM_CALLBACK_PROTOCOL is the defined interface for access to
custom NVS devices as well as communication of user selections in a more
interactive environment. This protocol should be published by platform-specific
drivers that want to export access to custom hardware storage or publish IFR
that has a requirement to call back the original driver.
**/
struct _EFI_FORM_CALLBACK_PROTOCOL {
EFI_NV_READ NvRead; ///< The read operation to access the NV data serviced by a hardware-specific driver.
EFI_NV_WRITE NvWrite; ///< The write operation to access the NV data serviced by a hardware-specific driver.
EFI_FORM_CALLBACK Callback; ///< The function that is called from the configuration browser to communicate key value pairs.
};
extern EFI_GUID gEfiFormCallbackProtocolGuid;
#endif

1032
IntelFrameworkPkg/Include/Protocol/FrameworkHii.h Normal file
View File

File diff suppressed because it is too large Load Diff

662
IntelFrameworkPkg/Include/Protocol/FrameworkMpService.h Normal file
View File

@ -0,0 +1,662 @@
/** @file
When installed, the Framework MP Services Protocol produces a collection of
services that are needed for MP management, such as initialization and management
of application processors.
@par Note:
This protocol has been deprecated and has been replaced by the MP Services
Protocol from the UEFI Platform Initialization Specification 1.2, Volume 2:
Driver Execution Environment Core Interface.
The MP Services Protocol provides a generalized way of performing following tasks:
- Retrieving information of multi-processor environment and MP-related status of
specific processors.
- Dispatching user-provided function to APs.
- Maintain MP-related processor status.
The MP Services Protocol must be produced on any system with more than one logical
processor.
The Protocol is available only during boot time.
MP Services Protocol is hardware-independent. Most of the logic of this protocol
is architecturally neutral. It abstracts the multi-processor environment and
status of processors, and provides interfaces to retrieve information, maintain,
and dispatch.
MP Services Protocol may be consumed by ACPI module. The ACPI module may use this
protocol to retrieve data that are needed for an MP platform and report them to OS.
MP Services Protocol may also be used to program and configure processors, such
as MTRR synchronization for memory space attributes setting in DXE Services.
MP Services Protocol may be used by non-CPU DXE drivers to speed up platform boot
by taking advantage of the processing capabilities of the APs, for example, using
APs to help test system memory in parallel with other device initialization.
Diagnostics applications may also use this protocol for multi-processor.
Copyright (c) 1999 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _FRAMEWORK_MP_SERVICE_PROTOCOL_H_
#define _FRAMEWORK_MP_SERVICE_PROTOCOL_H_
#include <FrameworkDxe.h>
///
/// Global ID for the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL.
///
#define FRAMEWORK_EFI_MP_SERVICES_PROTOCOL_GUID \
{ \
0xf33261e7, 0x23cb, 0x11d5, {0xbd, 0x5c, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} \
}
///
/// Forward declaration for the EFI_MP_SERVICES_PROTOCOL.
///
typedef struct _FRAMEWORK_EFI_MP_SERVICES_PROTOCOL FRAMEWORK_EFI_MP_SERVICES_PROTOCOL;
///
/// Fixed delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_FIXED 0x0
///
/// Lowest priority delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_LOWEST_PRIORITY 0x1
///
/// SMI delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_SMI 0x2
///
/// Remote read delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_REMOTE_READ 0x3
///
/// NMI delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_NMI 0x4
///
/// INIT delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_INIT 0x5
///
/// Startup IPI delivery mode that may be used as the DeliveryMode parameter in SendIpi().
///
#define DELIVERY_MODE_SIPI 0x6
///
/// The DeliveryMode parameter in SendIpi() must be less than this maximum value.
///
#define DELIVERY_MODE_MAX 0x7
///
/// IPF specific value for the state field of the Self Test State Parameter.
///
#define EFI_MP_HEALTH_FLAGS_STATUS_HEALTHY 0x0
///
/// IPF specific value for the state field of the Self Test State Parameter.
///
#define EFI_MP_HEALTH_FLAGS_STATUS_PERFORMANCE_RESTRICTED 0x1
///
/// IPF specific value for the state field of the Self Test State Parameter.
///
#define EFI_MP_HEALTH_FLAGS_STATUS_FUNCTIONALLY_RESTRICTED 0x2
typedef union {
///
/// Bitfield structure for the IPF Self Test State Parameter.
///
struct {
UINT32 Status:2;
UINT32 Tested:1;
UINT32 Reserved1:13;
UINT32 VirtualMemoryUnavailable:1;
UINT32 Ia32ExecutionUnavailable:1;
UINT32 FloatingPointUnavailable:1;
UINT32 MiscFeaturesUnavailable:1;
UINT32 Reserved2:12;
} Bits;
///
/// IA32 and X64 BIST data of the processor.
///
UINT32 Uint32;
} EFI_MP_HEALTH_FLAGS;
typedef struct {
///
/// @par IA32, X64:
/// BIST (built-in self-test) data of the processor.
///
/// @par IPF:
/// Lower 32 bits of the self-test state parameter. For definition of self-test
/// state parameter, please refer to Intel(R) Itanium(R) Architecture Software
/// Developer's Manual, Volume 2: System Architecture.
///
EFI_MP_HEALTH_FLAGS Flags;
///
/// @par IA32, X64:
/// Not used.
///
/// @par IPF:
/// Higher 32 bits of self test state parameter.
///
UINT32 TestStatus;
} EFI_MP_HEALTH;
typedef enum {
EfiCpuAP = 0, ///< The CPU is an AP (Application Processor).
EfiCpuBSP, ///< The CPU is the BSP (Boot-Strap Processor).
EfiCpuDesignationMaximum
} EFI_CPU_DESIGNATION;
typedef struct {
///
/// @par IA32, X64:
/// The lower 8 bits contains local APIC ID, and higher bits are reserved.
///
/// @par IPF:
/// The lower 16 bits contains id/eid as physical address of local SAPIC
/// unit, and higher bits are reserved.
///
UINT32 ApicID;
///
/// This field indicates whether the processor is enabled. If the value is
/// TRUE, then the processor is enabled. Otherwise, it is disabled.
///
BOOLEAN Enabled;
///
/// This field indicates whether the processor is playing the role of BSP.
/// If the value is EfiCpuAP, then the processor is AP. If the value is
/// EfiCpuBSP, then the processor is BSP.
///
EFI_CPU_DESIGNATION Designation;
///
/// @par IA32, X64:
/// The Flags field of this EFI_MP_HEALTH data structure holds BIST (built-in
/// self test) data of the processor. The TestStatus field is not used, and
/// the value is always zero.
///
/// @par IPF:
/// Bit format of this field is the same as the definition of self-test state
/// parameter, in Intel(R) Itanium(R) Architecture Software Developer's Manual,
/// Volume 2: System Architecture.
///
EFI_MP_HEALTH Health;
///
/// Zero-based physical package number that identifies the cartridge of the
/// processor.
///
UINTN PackageNumber;
///
/// Zero-based physical core number within package of the processor.
///
UINTN NumberOfCores;
///
/// Zero-based logical thread number within core of the processor.
///
UINTN NumberOfThreads;
///
/// This field is reserved.
///
UINT64 ProcessorPALCompatibilityFlags;
///
/// @par IA32, X64:
/// This field is not used, and the value is always zero.
///
/// @par IPF:
/// This field is a mask number that is handed off by the PAL about which
/// processor tests are performed and which are masked.
///
UINT64 ProcessorTestMask;
} EFI_MP_PROC_CONTEXT;
/**
This service retrieves general information of multiprocessors in the system.
This function is used to get the following information:
- Number of logical processors in system
- Maximal number of logical processors supported by system
- Number of enabled logical processors.
- Rendezvous interrupt number (IPF-specific)
- Length of the rendezvous procedure.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[out] NumberOfCPUs The pointer to the total number of logical processors
in the system, including the BSP and disabled
APs. If NULL, this parameter is ignored.
@param[out] MaximumNumberOfCPUs Pointer to the maximum number of processors
supported by the system. If NULL, this
parameter is ignored.
@param[out] NumberOfEnabledCPUs The pointer to the number of enabled logical
processors that exist in system, including
the BSP. If NULL, this parameter is ignored.
@param[out] RendezvousIntNumber This parameter is only meaningful for IPF.
- IA32, X64: The returned value is zero.
If NULL, this parameter is ignored.
- IPF: Pointer to the rendezvous interrupt
number that is used for AP wake-up.
@param[out] RendezvousProcLength The pointer to the length of rendezvous procedure.
- IA32, X64: The returned value is 0x1000.
If NULL, this parameter is ignored.
- IPF: The returned value is zero.
@retval EFI_SUCCESS Multiprocessor general information was successfully retrieved.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_MP_SERVICES_GET_GENERAL_MP_INFO)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
OUT UINTN *NumberOfCPUs OPTIONAL,
OUT UINTN *MaximumNumberOfCPUs OPTIONAL,
OUT UINTN *NumberOfEnabledCPUs OPTIONAL,
OUT UINTN *RendezvousIntNumber OPTIONAL,
OUT UINTN *RendezvousProcLength OPTIONAL
);
/**
This service gets detailed MP-related information of the requested processor.
This service gets detailed MP-related information of the requested processor
at the instant this call is made. Note the following:
- The processor information may change during the course of a boot session.
- The data of information presented here is entirely MP related.
Information regarding the number of caches and their sizes, frequency of operation,
slot numbers is all considered platform-related information and will not be
presented here.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[in] ProcessorNumber The handle number of the processor. The range
is from 0 to the total number of logical
processors minus 1. The total number of
logical processors can be retrieved by
GetGeneralMPInfo().
@param[in,out] BufferLength On input, pointer to the size in bytes of
ProcessorContextBuffer. On output, if the
size of ProcessorContextBuffer is not large
enough, the value pointed by this parameter
is updated to size in bytes that is needed.
If the size of ProcessorContextBuffer is
sufficient, the value is not changed from
input.
@param[out] ProcessorContextBuffer The pointer to the buffer where the data of
requested processor will be deposited.
The buffer is allocated by caller.
@retval EFI_SUCCESS Processor information was successfully returned.
@retval EFI_BUFFER_TOO_SMALL The size of ProcessorContextBuffer is too small.
The value pointed by BufferLength has been updated
to size in bytes that is needed.
@retval EFI_INVALID_PARAMETER IA32, X64:BufferLength is NULL.
@retval EFI_INVALID_PARAMETER IA32, X64:ProcessorContextBuffer is NULL.
@retval EFI_INVALID_PARAMETER IA32, X64:Processor with the handle specified by
ProcessorNumber does not exist.
@retval EFI_NOT_FOUND IPF: Processor with the handle specified by
ProcessorNumber does not exist.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_MP_SERVICES_GET_PROCESSOR_CONTEXT)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
IN UINTN ProcessorNumber,
IN OUT UINTN *BufferLength,
OUT EFI_MP_PROC_CONTEXT *ProcessorContextBuffer
);
/**
This function is used to dispatch all enabled APs to the function specified
by Procedure. APs can run either simultaneously or one by one. The caller can
also configure the BSP to either wait for APs or just proceed with the next
task. It is the responsibility of the caller of the StartupAllAPs() to make
sure that the nature of the code that will be run on the BSP and the dispatched
APs is well controlled. The MP Services Protocol does not guarantee that the
function that either processor is executing is MP-safe. Hence, the tasks that
can be run in parallel are limited to certain independent tasks and well-
controlled exclusive code. EFI services and protocols may not be called by APs
unless otherwise specified.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[in] Procedure A pointer to the function to be run on enabled
APs of the system.
@param[in] SingleThread Flag that requests APs to execute one at a
time or simultaneously.
- IA32, X64:
If TRUE, then all the enabled APs execute
the function specified by Procedure one by
one, in ascending order of processor handle
number. If FALSE, then all the enabled APs
execute the function specified by Procedure
simultaneously.
- IPF:
If TRUE, then all the enabled APs execute
the function specified by Procedure simultaneously.
If FALSE, then all the enabled APs execute the
function specified by Procedure one by one, in
ascending order of processor handle number. The
time interval of AP dispatching is determined
by WaitEvent and TimeoutInMicrosecs.
@param[in] WaitEvent Event to signal when APs have finished.
- IA32, X64:
If not NULL, when all APs finish after timeout
expires, the event will be signaled. If NULL,
the parameter is ignored.
- IPF:
If SingleThread is TRUE, this parameter
is ignored. If SingleThread is FALSE (i.e.
dispatch APs one by one), this parameter
determines whether the BSP waits after each
AP is dispatched. If it is NULL, the BSP
does not wait after each AP is dispatched.
If it is not NULL, the BSP waits after each
AP is dispatched, and the time interval is
determined by TimeoutInMicrosecs. Type
EFI_EVENT is defined in CreateEvent() in
the Unified Extensible Firmware Interface
Specification.
@param[in] TimeoutInMicrosecsond Time to wait for APs to finish.
- IA32, X64:
If the value is zero, it means no timeout
limit. The BSP waits until all APs finish.
If the value is not zero, the BSP waits
until all APs finish or timeout expires.
If timeout expires, EFI_TIMEOUT is returned,
and the BSP will then check APs?status
periodically, with time interval of 16
microseconds.
- IPF:
If SingleThread is TRUE and FailedCPUList
is NULL, this parameter is ignored. If
SingleThread is TRUE and FailedCPUList is
not NULL, this parameter determines whether
the BSP waits until all APs finish their
procedure. If it is zero, the BSP does not
wait for APs. If it is non-zero, it waits
until all APs finish. If SingleThread is
FALSE and WaitEvent is NULL, this parameter
is ignored. If SingleThread is FALSE and
WaitEvent is not NULL, the BSP waits after
each AP is dispatched and this value
determines time interval. If the value is
zero, the length of time interval is 10ms.
If the value is non-zero, the BSP waits
until dispatched AP finishes and then
dispatch the next.
@param[in] ProcedureArgument The pointer to the optional parameter of the
function specified by Procedure.
@param[out] FailedCPUList List of APs that did not finish.
- IA32, X64:
If not NULL, it records handle numbers of
all logical processors that fail to accept
caller-provided function (busy or disabled).
If NULL, this parameter is ignored.
- IPF:
If not NULL, it records status of all
logical processors, with processor handle
number as index. If a logical processor
fails to accept caller-provided function
because it is busy, the status is EFI_NOT_READY.
If it fails to accept function due to other
reasons, the status is EFI_NOT_AVAILABLE_YET.
If timeout expires, the status is EFI_TIMEOUT.
Otherwise, the value is EFI_SUCCESS. If NULL,
this parameter is ignored.
@retval EFI_SUCCESS IA32, X64: All dispatched APs have finished
before the timeout expires.
@retval EFI_SUCCESS IA32, X64: Only 1 logical processor exists
in system.
@retval EFI_INVALID_PARAMETER IA32, X64: Procedure is NULL.
@retval EFI_TIMEOUT IA32, X64: The timeout expires before all
dispatched APs have finished.
@retval EFI_SUCCESS IPF: This function always returns EFI_SUCCESS.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_STARTUP_ALL_APS)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
IN FRAMEWORK_EFI_AP_PROCEDURE Procedure,
IN BOOLEAN SingleThread,
IN EFI_EVENT WaitEvent OPTIONAL,
IN UINTN TimeoutInMicroSecs,
IN VOID *ProcArguments OPTIONAL,
OUT UINTN *FailedCPUList OPTIONAL
);
/**
This function is used to dispatch one enabled AP to the function provided by
the caller. The caller can request the BSP to either wait for the AP or just
proceed with the next task.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[in] Procedure A pointer to the function to be run on the
designated AP.
@param[in] ProcessorNumber The handle number of AP. The range is from
0 to the total number of logical processors
minus 1. The total number of logical
processors can be retrieved by GetGeneralMPInfo().
@param[in] WaitEvent Event to signal when APs have finished.
- IA32, X64:
If not NULL, when the AP finishes after timeout
expires, the event will be signaled. If NULL,
the parameter is ignored.
- IPF:
This parameter determines whether the BSP
waits after the AP is dispatched. If it is
NULL, the BSP does not wait after the AP
is dispatched. If it is not NULL, the BSP
waits after the AP is dispatched, and the
time interval is determined by TimeoutInMicrosecs.
Type EFI_EVENT is defined in CreateEvent()
in the Unified Extensible Firmware Interface
Specification.
@param[in] TimeoutInMicrosecsond Time to wait for APs to finish.
- IA32, X64:
If the value is zero, it means no timeout
limit. The BSP waits until the AP finishes.
If the value is not zero, the BSP waits until
the AP finishes or timeout expires. If timeout
expires, EFI_TIMEOUT is returned, and the
BSP will then check the AP's status periodically,
with time interval of 16 microseconds.
- IPF:
If WaitEvent is NULL, this parameter is ignored.
If WaitEvent is not NULL, the BSP waits after
the AP is dispatched and this value determines
time interval. If the value is zero, the length
of time interval is 10ms. If the value is
non-zero, the BSP waits until the AP finishes.
@param[in] ProcedureArgument The pointer to the optional parameter of the
function specified by Procedure.
@retval EFI_SUCCESS Specified AP has finished before the timeout
expires.
@retval EFI_TIMEOUT The timeout expires before specified AP has
finished.
@retval EFI_INVALID_PARAMETER IA32, X64: Processor with the handle specified
by ProcessorNumber does not exist.
@retval EFI_INVALID_PARAMETER IA32, X64: Specified AP is busy or disabled.
@retval EFI_INVALID_PARAMETER IA32, X64: Procedure is NULL.
@retval EFI_INVALID_PARAMETER IA32, X64: ProcessorNumber specifies the BSP
@retval EFI_NOT_READY IPF: Specified AP is busy
@retval EFI_NOT_AVAILABLE_YET IPF: ProcessorNumber specifies the BSP
@retval EFI_NOT_AVAILABLE_YET IPF: Specified AP is disabled.
@retval EFI_NOT_AVAILABLE_YET IPF: Specified AP is unhealthy or untested.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_STARTUP_THIS_AP)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
IN FRAMEWORK_EFI_AP_PROCEDURE Procedure,
IN UINTN ProcessorNumber,
IN EFI_EVENT WaitEvent OPTIONAL,
IN UINTN TimeoutInMicroSecs,
IN OUT VOID *ProcArguments OPTIONAL
);
/**
This service switches the requested AP to be the BSP from that point onward.
The new BSP can take over the execution of the old BSP and continue seamlessly
from where the old one left off. This call can only be performed by the
current BSP.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[in] ProcessorNumber The handle number of AP. The range is from 0 to
the total number of logical processors minus 1.
The total number of logical processors can be
retrieved by GetGeneralMPInfo().
@param[in] EnableOldBSP If TRUE, then the old BSP will be listed as an
enabled AP. Otherwise, it will be disabled.
@retval EFI_SUCCESS BSP successfully switched.
@retval EFI_INVALID_PARAMETER The processor with the handle specified by
ProcessorNumber does not exist.
@retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP.
@retval EFI_NOT_READY IA32, X64: Specified AP is busy or disabled.
@retval EFI_INVALID_PARAMETER IPF: Specified AP is disabled.
@retval EFI_INVALID_PARAMETER IPF: Specified AP is unhealthy or untested.
@retval EFI_NOT_READY IPF: Specified AP is busy.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_SWITCH_BSP)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
IN UINTN ProcessorNumber,
IN BOOLEAN EnableOldBSP
);
/**
This service sends an IPI to a specified AP. Caller can specify vector number
and delivery mode of the interrupt.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[in] ProcessorNumber The handle number of AP. The range is from 0 to
the total number of logical processors minus 1.
The total number of logical processors can be
retrieved by GetGeneralMPInfo().
@param[in] VectorNumber The vector number of the interrupt.
@param[in] DeliveryMode The delivery mode of the interrupt.
@retval EFI_SUCCESS IPI was successfully sent.
@retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP.
@retval EFI_INVALID_PARAMETER IA32, X64: Processor with the handle specified
by ProcessorNumber does not exist.
@retval EFI_INVALID_PARAMETER IA32, X64: VectorNumber is greater than 255.
@retval EFI_INVALID_PARAMETER IA32, X64: DeliveryMode is greater than or equal
to DELIVERY_MODE_MAX.
@retval EFI_NOT_READY IA32, X64: IPI is not accepted by the target
processor within 10 microseconds.
@retval EFI_INVALID_PARAMETER IPF: Specified AP is disabled.
@retval EFI_INVALID_PARAMETER IPF: Specified AP is unhealthy or untested.
@retval EFI_NOT_READY IPF: Specified AP is busy.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_MP_SERVICES_SEND_IPI)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
IN UINTN ProcessorNumber,
IN UINTN VectorNumber,
IN UINTN DeliveryMode
);
/**
This service lets the caller enable or disable an AP. The caller can optionally
specify the health status of the AP by Health. It is usually used to update the
health status of the processor after some processor test.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[in] ProcessorNumber The handle number of AP. The range is from 0 to
the total number of logical processors minus 1.
The total number of logical processors can be
retrieved by GetGeneralMPInfo().
@param[in] NewAPState Indicates whether the new, desired state of the
AP is enabled or disabled. TRUE for enabling,
FALSE otherwise.
@param[in] HealthState If not NULL, it points to the value that specifies
the new health status of the AP. If it is NULL,
this parameter is ignored.
@retval EFI_SUCCESS AP successfully enabled or disabled.
@retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP.
@retval EFI_INVALID_PARAMETER IA32, X64: Processor with the handle specified
by ProcessorNumber does not exist.
@retval EFI_INVALID_PARAMETER IPF: If an unhealthy or untested AP is to be
enabled.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_ENABLEDISABLEAP)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
IN UINTN ProcessorNumber,
IN BOOLEAN NewAPState,
IN EFI_MP_HEALTH *HealthState OPTIONAL
);
/**
This service lets the caller processor get its handle number, with which any
processor in the system can be uniquely identified. The range is from 0 to the
total number of logical processors minus 1. The total number of logical
processors can be retrieved by GetGeneralMPInfo(). This service may be called
from the BSP and APs.
@param[in] This The pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
instance.
@param[out] ProcessorNumber A pointer to the handle number of AP. The range is
from 0 to the total number of logical processors
minus 1. The total number of logical processors
can be retrieved by GetGeneralMPInfo().
@retval EFI_SUCCESS This function always returns EFI_SUCCESS.
**/
typedef
EFI_STATUS
(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_WHOAMI)(
IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This,
OUT UINTN *ProcessorNumber
);
///
/// Framework MP Services Protocol structure.
///
struct _FRAMEWORK_EFI_MP_SERVICES_PROTOCOL {
EFI_MP_SERVICES_GET_GENERAL_MP_INFO GetGeneralMPInfo;
EFI_MP_SERVICES_GET_PROCESSOR_CONTEXT GetProcessorContext;
FRAMEWORK_EFI_MP_SERVICES_STARTUP_ALL_APS StartupAllAPs;
FRAMEWORK_EFI_MP_SERVICES_STARTUP_THIS_AP StartupThisAP;
FRAMEWORK_EFI_MP_SERVICES_SWITCH_BSP SwitchBSP;
EFI_MP_SERVICES_SEND_IPI SendIPI;
FRAMEWORK_EFI_MP_SERVICES_ENABLEDISABLEAP EnableDisableAP;
FRAMEWORK_EFI_MP_SERVICES_WHOAMI WhoAmI;
};
extern EFI_GUID gFrameworkEfiMpServiceProtocolGuid;
#endif

297
IntelFrameworkPkg/Include/Protocol/Legacy8259.h Normal file
View File

@ -0,0 +1,297 @@
/** @file
This protocol abstracts the 8259 interrupt controller. This includes
PCI IRQ routing needed to program the PCI Interrupt Line register.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.97.
**/
#ifndef _EFI_LEGACY_8259_H_
#define _EFI_LEGACY_8259_H_
#define EFI_LEGACY_8259_PROTOCOL_GUID \
{ \
0x38321dba, 0x4fe0, 0x4e17, {0x8a, 0xec, 0x41, 0x30, 0x55, 0xea, 0xed, 0xc1 } \
}
typedef struct _EFI_LEGACY_8259_PROTOCOL EFI_LEGACY_8259_PROTOCOL;
typedef enum {
Efi8259Irq0,
Efi8259Irq1,
Efi8259Irq2,
Efi8259Irq3,
Efi8259Irq4,
Efi8259Irq5,
Efi8259Irq6,
Efi8259Irq7,
Efi8259Irq8,
Efi8259Irq9,
Efi8259Irq10,
Efi8259Irq11,
Efi8259Irq12,
Efi8259Irq13,
Efi8259Irq14,
Efi8259Irq15,
Efi8259IrqMax
} EFI_8259_IRQ;
typedef enum {
Efi8259LegacyMode,
Efi8259ProtectedMode,
Efi8259MaxMode
} EFI_8259_MODE;
/**
Get the 8259 interrupt masks for Irq0 - Irq15. A different mask exists for
the legacy mode mask and the protected mode mask. The base address for the 8259
is different for legacy and protected mode, so two masks are required.
@param This The protocol instance pointer.
@param MasterBase The base vector for the Master PIC in the 8259 controller.
@param SlaveBase The base vector for the Slave PIC in the 8259 controller.
@retval EFI_SUCCESS The new bases were programmed.
@retval EFI_DEVICE_ERROR A device error occured programming the vector bases.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_SET_VECTOR_BASE)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN UINT8 MasterBase,
IN UINT8 SlaveBase
);
/**
Get the 8259 interrupt masks for Irq0 - Irq15. A different mask exists for
the legacy mode mask and the protected mode mask. The base address for the 8259
is different for legacy and protected mode, so two masks are required.
@param This The protocol instance pointer.
@param LegacyMask Bit 0 is Irq0 - Bit 15 is Irq15.
@param LegacyEdgeLevel Bit 0 is Irq0 - Bit 15 is Irq15.
@param ProtectedMask Bit 0 is Irq0 - Bit 15 is Irq15.
@param ProtectedEdgeLevel Bit 0 is Irq0 - Bit 15 is Irq15.
@retval EFI_SUCCESS 8259 status returned.
@retval EFI_DEVICE_ERROR Error reading 8259.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_GET_MASK)(
IN EFI_LEGACY_8259_PROTOCOL *This,
OUT UINT16 *LegacyMask, OPTIONAL
OUT UINT16 *LegacyEdgeLevel, OPTIONAL
OUT UINT16 *ProtectedMask, OPTIONAL
OUT UINT16 *ProtectedEdgeLevel OPTIONAL
);
/**
Set the 8259 interrupt masks for Irq0 - Irq15. A different mask exists for
the legacy mode mask and the protected mode mask. The base address for the 8259
is different for legacy and protected mode, so two masks are required.
Also set the edge/level masks.
@param This The protocol instance pointer.
@param LegacyMask Bit 0 is Irq0 - Bit 15 is Irq15.
@param LegacyEdgeLevel Bit 0 is Irq0 - Bit 15 is Irq15.
@param ProtectedMask Bit 0 is Irq0 - Bit 15 is Irq15.
@param ProtectedEdgeLevel Bit 0 is Irq0 - Bit 15 is Irq15.
@retval EFI_SUCCESS 8259 status returned.
@retval EFI_DEVICE_ERROR Error writing 8259.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_SET_MASK)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN UINT16 *LegacyMask, OPTIONAL
IN UINT16 *LegacyEdgeLevel, OPTIONAL
IN UINT16 *ProtectedMask, OPTIONAL
IN UINT16 *ProtectedEdgeLevel OPTIONAL
);
/**
Set the 8259 mode of operation. The base address for the 8259 is different for
legacy and protected mode. The legacy mode requires the master 8259 to have a
master base of 0x08 and the slave base of 0x70. The protected mode base locations
are not defined. Interrupts must be masked by the caller before this function
is called. The interrupt mask from the current mode is saved. The interrupt
mask for the new mode is Mask, or if Mask does not exist the previously saved
mask is used.
@param This The protocol instance pointer.
@param Mode The mode of operation. i.e. the real mode or protected mode.
@param Mask Optional interupt mask for the new mode.
@param EdgeLevel Optional trigger mask for the new mode.
@retval EFI_SUCCESS 8259 programmed.
@retval EFI_DEVICE_ERROR Error writing to 8259.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_SET_MODE)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN EFI_8259_MODE Mode,
IN UINT16 *Mask, OPTIONAL
IN UINT16 *EdgeLevel OPTIONAL
);
/**
Convert from IRQ to processor interrupt vector number.
@param This The protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15.
@param Vector The processor vector number that matches an Irq.
@retval EFI_SUCCESS The Vector matching Irq is returned.
@retval EFI_INVALID_PARAMETER The Irq not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_GET_VECTOR)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN EFI_8259_IRQ Irq,
OUT UINT8 *Vector
);
/**
Enable Irq by unmasking interrupt in 8259
@param This The protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15.
@param LevelTriggered TRUE if level triggered. FALSE if edge triggered.
@retval EFI_SUCCESS The Irq was enabled on 8259.
@retval EFI_INVALID_PARAMETER The Irq is not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_ENABLE_IRQ)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN EFI_8259_IRQ Irq,
IN BOOLEAN LevelTriggered
);
/**
Disable Irq by masking interrupt in 8259
@param This The protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15.
@retval EFI_SUCCESS The Irq was disabled on 8259.
@retval EFI_INVALID_PARAMETER The Irq is not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_DISABLE_IRQ)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN EFI_8259_IRQ Irq
);
/**
PciHandle represents a PCI config space of a PCI function. Vector
represents Interrupt Pin (from PCI config space) and it is the data
that is programmed into the Interrupt Line (from the PCI config space)
register.
@param This The protocol instance pointer.
@param PciHandle The PCI function to return the vector for.
@param Vector The vector for the function it matches.
@retval EFI_SUCCESS A valid Vector was returned.
@retval EFI_INVALID_PARAMETER PciHandle not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_GET_INTERRUPT_LINE)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN EFI_HANDLE PciHandle,
OUT UINT8 *Vector
);
/**
Send an EOI to 8259
@param This The protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15.
@retval EFI_SUCCESS EOI was successfully sent to 8259.
@retval EFI_INVALID_PARAMETER The Irq isnot valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_END_OF_INTERRUPT)(
IN EFI_LEGACY_8259_PROTOCOL *This,
IN EFI_8259_IRQ Irq
);
/**
@par Protocol Description:
Abstracts the 8259 and APIC hardware control between EFI usage and
Compatibility16 usage.
@param SetVectorBase
Sets the vector bases for master and slave PICs.
@param GetMask
Gets IRQ and edge/level masks for 16-bit real mode and 32-bit protected mode.
@param SetMask
Sets the IRQ and edge\level masks for 16-bit real mode and 32-bit protected mode.
@param SetMode
Sets PIC mode to 16-bit real mode or 32-bit protected mode.
@param GetVector
Gets the base vector assigned to an IRQ.
@param EnableIrq
Enables an IRQ.
@param DisableIrq
Disables an IRQ.
@param GetInterruptLine
Gets an IRQ that is assigned to a PCI device.
@param EndOfInterrupt
Issues the end of interrupt command.
**/
struct _EFI_LEGACY_8259_PROTOCOL {
EFI_LEGACY_8259_SET_VECTOR_BASE SetVectorBase;
EFI_LEGACY_8259_GET_MASK GetMask;
EFI_LEGACY_8259_SET_MASK SetMask;
EFI_LEGACY_8259_SET_MODE SetMode;
EFI_LEGACY_8259_GET_VECTOR GetVector;
EFI_LEGACY_8259_ENABLE_IRQ EnableIrq;
EFI_LEGACY_8259_DISABLE_IRQ DisableIrq;
EFI_LEGACY_8259_GET_INTERRUPT_LINE GetInterruptLine;
EFI_LEGACY_8259_END_OF_INTERRUPT EndOfInterrupt;
};
extern EFI_GUID gEfiLegacy8259ProtocolGuid;
#endif

1559
IntelFrameworkPkg/Include/Protocol/LegacyBios.h Normal file
View File

File diff suppressed because it is too large Load Diff

761
IntelFrameworkPkg/Include/Protocol/LegacyBiosPlatform.h Normal file
View File

@ -0,0 +1,761 @@
/** @file
The EFI Legacy BIOS Patform Protocol is used to mate a Legacy16
implementation with this EFI code. The EFI driver that produces
the Legacy BIOS protocol is generic and consumes this protocol.
A driver that matches the Legacy16 produces this protocol
Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.97.
**/
#ifndef _EFI_LEGACY_BIOS_PLATFORM_H_
#define _EFI_LEGACY_BIOS_PLATFORM_H_
///
/// Legacy BIOS Platform depends on HDD_INFO and EFI_COMPATIBILITY16_TABLE that
/// are defined with the Legacy BIOS Protocol
///
#include <Protocol/LegacyBios.h>
#define EFI_LEGACY_BIOS_PLATFORM_PROTOCOL_GUID \
{ \
0x783658a3, 0x4172, 0x4421, {0xa2, 0x99, 0xe0, 0x9, 0x7, 0x9c, 0xc, 0xb4 } \
}
typedef struct _EFI_LEGACY_BIOS_PLATFORM_PROTOCOL EFI_LEGACY_BIOS_PLATFORM_PROTOCOL;
/**
This enum specifies the Mode param values for GetPlatformInfo()
**/
typedef enum {
///
/// This mode is invoked twice. The first invocation has LegacySegment and
/// LegacyOffset set to 0. The mode returns the MP table address in EFI memory, along with its size.
/// The second invocation has LegacySegment and LegacyOffset set to the location
/// in the 0xF0000 or 0xE0000 block to which the MP table is to be copied. The second
/// invocation allows any MP table address fixes to occur in the EFI memory copy of the
/// MP table. The caller, not EfiGetPlatformBinaryMpTable, copies the modified MP
/// table to the allocated region in 0xF0000 or 0xE0000 block after the second invocation.
///
/// The function parameters associated with this mode are:
///
/// Table Pointer to the MP table.
///
/// TableSize Size in bytes of the MP table.
///
/// Location Location to place table. 0x00. Either 0xE0000 or 0xF0000 64 KB blocks.
/// Bit 0 = 1 0xF0000 64 KB block.
/// Bit 1 = 1 0xE0000 64 KB block.
/// Multiple bits can be set.
///
/// Alignment Bit-mapped address alignment granularity.
/// The first nonzero bit from the right is the address granularity.
///
// LegacySegment Segment in which EfiCompatibility code will place the MP table.
///
/// LegacyOffset Offset in which EfiCompatibility code will place the MP table.
///
/// The return values associated with this mode are:
///
/// EFI_SUCCESS The MP table was returned.
///
/// EFI_UNSUPPORTED The MP table is not supported on this platform.
///
EfiGetPlatformBinaryMpTable = 0,
///
/// This mode returns a block of data. The content and usage is IBV or OEM defined.
/// OEMs or IBVs normally use this function for nonstandard Compatibility16 runtime soft
/// INTs. It is the responsibility of this routine to coalesce multiple OEM 16 bit functions, if
/// they exist, into one coherent package that is understandable by the Compatibility16 code.
/// This function is invoked twice. The first invocation has LegacySegment and
/// LegacyOffset set to 0. The function returns the table address in EFI memory, as well as its size.
/// The second invocation has LegacySegment and LegacyOffset set to the location
/// in the 0xF0000 or 0xE0000 block to which the data (table) is to be copied. The second
/// invocation allows any data (table) address fixes to occur in the EFI memory copy of
/// the table. The caller, not GetOemIntData(), copies the modified data (table) to the
/// allocated region in 0xF0000 or 0xE0000 block after the second invocation.
///
/// The function parameters associated with this mode are:
///
/// Table Pointer to OEM legacy 16 bit code or data.
///
/// TableSize Size of data.
///
/// Location Location to place table. 0x00. Either 0xE0000 or 0xF0000 64 KB blocks.
/// Bit 0 = 1 0xF0000 64 KB block.
/// Bit 1 = 1 0xE0000 64 KB block.
/// Multiple bits can be set.
///
/// Alignment Bit mapped address alignment granularity.
/// The first nonzero bit from the right is the address granularity.
///
/// LegacySegment Segment in which EfiCompatibility code will place the table or data.
///
/// LegacyOffset Offset in which EfiCompatibility code will place the table or data.
///
/// The return values associated with this mode are:
///
/// EFI_SUCCESS The data was returned successfully.
///
/// EFI_UNSUPPORTED Oem INT is not supported on this platform.
///
EfiGetPlatformBinaryOemIntData = 1,
///
/// This mode returns a block of data. The content and usage is IBV defined. OEMs or
/// IBVs normally use this mode for nonstandard Compatibility16 runtime 16 bit routines. It
/// is the responsibility of this routine to coalesce multiple OEM 16 bit functions, if they
/// exist, into one coherent package that is understandable by the Compatibility16 code.
///
/// Example usage: A legacy mobile BIOS that has a pre-existing runtime
/// interface to return the battery status to calling applications.
///
/// This mode is invoked twice. The first invocation has LegacySegment and
/// LegacyOffset set to 0. The mode returns the table address in EFI memory and its size.
/// The second invocation has LegacySegment and LegacyOffset set to the location
/// in the 0xF0000 or 0xE0000 block to which the table is to be copied. The second
/// invocation allows any table address fixes to occur in the EFI memory copy of the table.
/// The caller, not EfiGetPlatformBinaryOem16Data, copies the modified table to
/// the allocated region in 0xF0000 or 0xE0000 block after the second invocation.
///
/// The function parameters associated with this mode are:
///
/// Table Pointer to OEM legacy 16 bit code or data.
///
/// TableSize Size of data.
///
/// Location Location to place the table. 0x00. Either 0xE0000 or 0xF0000 64 KB blocks.
/// Bit 0 = 1 0xF0000 64 KB block.
/// Bit 1 = 1 0xE0000 64 KB block.
/// Multiple bits can be set.
///
/// Alignment Bit mapped address alignment granularity.
/// The first nonzero bit from the right is the address granularity.
///
/// LegacySegment Segment in which EfiCompatibility code will place the table or data.
///
/// LegacyOffset Offset in which EfiCompatibility code will place the table or data.
///
/// The return values associated with this mode are:
///
/// EFI_SUCCESS The data was returned successfully.
///
/// EFI_UNSUPPORTED Oem16 is not supported on this platform.
///
EfiGetPlatformBinaryOem16Data = 2,
///
/// This mode returns a block of data. The content and usage are IBV defined. OEMs or
/// IBVs normally use this mode for nonstandard Compatibility16 runtime 32 bit routines. It
/// is the responsibility of this routine to coalesce multiple OEM 32 bit functions, if they
/// exist, into one coherent package that is understandable by the Compatibility16 code.
///
/// Example usage: A legacy mobile BIOS that has a pre existing runtime
/// interface to return the battery status to calling applications.
///
/// This mode is invoked twice. The first invocation has LegacySegment and
/// LegacyOffset set to 0. The mode returns the table address in EFI memory and its size.
///
/// The second invocation has LegacySegment and LegacyOffset set to the location
/// in the 0xF0000 or 0xE0000 block to which the table is to be copied. The second
/// invocation allows any table address fix ups to occur in the EFI memory copy of the table.
/// The caller, not EfiGetPlatformBinaryOem32Data, copies the modified table to
/// the allocated region in 0xF0000 or 0xE0000 block after the second invocation..
///
/// Note: There are two generic mechanisms by which this mode can be used.
/// Mechanism 1: This mode returns the data and the Legacy BIOS Protocol copies
/// the data into the F0000 or E0000 block in the Compatibility16 code. The
/// EFI_COMPATIBILITY16_TABLE entries Oem32Segment and Oem32Offset can
/// be viewed as two UINT16 entries.
/// Mechanism 2: This mode directly fills in the EFI_COMPATIBILITY16_TABLE with
/// a pointer to the INT15 E820 region containing the 32 bit code. It returns
/// EFI_UNSUPPORTED. The EFI_COMPATIBILITY16_TABLE entries,
/// Oem32Segment and Oem32Offset, can be viewed as two UINT16 entries or
/// as a single UINT32 entry as determined by the IBV.
///
/// The function parameters associated with this mode are:
///
/// TableSize Size of data.
///
/// Location Location to place the table. 0x00 or 0xE0000 or 0xF0000 64 KB blocks.
/// Bit 0 = 1 0xF0000 64 KB block.
/// Bit 1 = 1 0xE0000 64 KB block.
/// Multiple bits can be set.
///
/// Alignment Bit mapped address alignment granularity.
/// The first nonzero bit from the right is the address granularity.
///
/// LegacySegment Segment in which EfiCompatibility code will place the table or data.
///
/// LegacyOffset Offset in which EfiCompatibility code will place the table or data.
///
/// The return values associated with this mode are:
/// EFI_SUCCESS The data was returned successfully.
/// EFI_UNSUPPORTED Oem32 is not supported on this platform.
///
EfiGetPlatformBinaryOem32Data = 3,
///
/// This mode returns a TPM binary image for the onboard TPM device.
///
/// The function parameters associated with this mode are:
///
/// Table TPM binary image for the onboard TPM device.
///
/// TableSize Size of BinaryImage in bytes.
///
/// Location Location to place the table. 0x00. Either 0xE0000 or 0xF0000 64 KB blocks.
/// Bit 0 = 1 0xF0000 64 KB block.
/// Bit 1 = 1 0xE0000 64 KB block.
/// Multiple bits can be set.
///
/// Alignment Bit mapped address alignment granularity.
/// The first nonzero bit from the right is the address granularity.
///
/// LegacySegment Segment in which EfiCompatibility code will place the table or data.
///
/// LegacyOffset Offset in which EfiCompatibility code will place the table or data.
///
/// The return values associated with this mode are:
///
/// EFI_SUCCESS BinaryImage is valid.
///
/// EFI_UNSUPPORTED Mode is not supported on this platform.
///
/// EFI_NOT_FOUND No BinaryImage was found.
///
EfiGetPlatformBinaryTpmBinary = 4,
///
/// The mode finds the Compatibility16 Rom Image.
///
/// The function parameters associated with this mode are:
///
/// System ROM image for the platform.
///
/// TableSize Size of Table in bytes.
///
/// Location Ignored.
///
/// Alignment Ignored.
///
/// LegacySegment Ignored.
///
/// LegacyOffset Ignored.
///
/// The return values associated with this mode are:
///
/// EFI_SUCCESS ROM image found.
///
/// EFI_NOT_FOUND ROM not found.
///
EfiGetPlatformBinarySystemRom = 5,
///
/// This mode returns the Base address of PciExpress memory mapped configuration
/// address space.
///
/// The function parameters associated with this mode are:
///
/// Table System ROM image for the platform.
///
/// TableSize Size of Table in bytes.
///
/// Location Ignored.
///
/// Alignment Ignored.
///
/// LegacySegment Ignored.
///
/// LegacyOffset Ignored.
///
/// The return values associated with this mode are:
///
/// EFI_SUCCESS Address is valid.
///
/// EFI_UNSUPPORTED System does not PciExpress.
///
EfiGetPlatformPciExpressBase = 6,
///
EfiGetPlatformPmmSize = 7,
///
EfiGetPlatformEndOpromShadowAddr = 8,
///
} EFI_GET_PLATFORM_INFO_MODE;
/**
This enum specifies the Mode param values for GetPlatformHandle().
**/
typedef enum {
///
/// This mode returns the Compatibility16 policy for the device that should be the VGA
/// controller used during a Compatibility16 boot.
///
/// The function parameters associated with this mode are:
///
/// Type 0x00.
///
/// HandleBuffer Buffer of all VGA handles found.
///
/// HandleCount Number of VGA handles found.
///
/// AdditionalData NULL.
///
EfiGetPlatformVgaHandle = 0,
///
/// This mode returns the Compatibility16 policy for the device that should be the IDE
/// controller used during a Compatibility16 boot.
///
/// The function parameters associated with this mode are:
///
/// Type 0x00.
///
/// HandleBuffer Buffer of all IDE handles found.
///
/// HandleCount Number of IDE handles found.
///
/// AdditionalData Pointer to HddInfo.
/// Information about all onboard IDE controllers.
///
EfiGetPlatformIdeHandle = 1,
///
/// This mode returns the Compatibility16 policy for the device that should be the ISA bus
/// controller used during a Compatibility16 boot.
///
/// The function parameters associated with this mode are:
///
/// Type 0x00.
///
/// HandleBuffer Buffer of all ISA bus handles found.
///
/// HandleCount Number of ISA bus handles found.
///
/// AdditionalData NULL.
///
EfiGetPlatformIsaBusHandle = 2,
///
/// This mode returns the Compatibility16 policy for the device that should be the USB
/// device used during a Compatibility16 boot.
///
/// The function parameters associated with this mode are:
///
/// Type 0x00.
///
/// HandleBuffer Buffer of all USB handles found.
///
/// HandleCount Number of USB bus handles found.
///
/// AdditionalData NULL.
///
EfiGetPlatformUsbHandle = 3
} EFI_GET_PLATFORM_HANDLE_MODE;
/**
This enum specifies the Mode param values for PlatformHooks().
Note: Any OEM defined hooks start with 0x8000.
**/
typedef enum {
///
/// This mode allows any preprocessing before scanning OpROMs.
///
/// The function parameters associated with this mode are:
///
/// Type 0.
///
/// DeviceHandle Handle of device OpROM is associated with.
///
/// ShadowAddress Address where OpROM is shadowed.
///
/// Compatibility16Table NULL.
///
/// AdditionalData NULL.
///
EfiPlatformHookPrepareToScanRom = 0,
///
/// This mode shadows legacy OpROMS that may not have a physical device associated with
/// them. It returns EFI_SUCCESS if the ROM was shadowed.
///
/// The function parameters associated with this mode are:
///
/// Type 0.
///
/// DeviceHandle 0.
///
/// ShadowAddress First free OpROM area, after other OpROMs have been dispatched..
///
/// Compatibility16Table Pointer to the Compatability16 Table.
///
/// AdditionalData NULL.
///
EfiPlatformHookShadowServiceRoms= 1,
///
/// This mode allows platform to perform any required operation after an OpROM has
/// completed its initialization.
///
/// The function parameters associated with this mode are:
///
/// Type 0.
///
/// DeviceHandle Handle of device OpROM is associated with.
///
/// ShadowAddress Address where OpROM is shadowed.
///
/// Compatibility16Table NULL.
///
/// AdditionalData NULL.
///
EfiPlatformHookAfterRomInit = 2
} EFI_GET_PLATFORM_HOOK_MODE;
///
/// This IRQ has not been assigned to PCI.
///
#define PCI_UNUSED 0x00
///
/// This IRQ has been assigned to PCI.
///
#define PCI_USED 0xFF
///
/// This IRQ has been used by an SIO legacy device and cannot be used by PCI.
///
#define LEGACY_USED 0xFE
#pragma pack(1)
typedef struct {
///
/// IRQ for this entry.
///
UINT8 Irq;
///
/// Status of this IRQ.
///
/// PCI_UNUSED 0x00. This IRQ has not been assigned to PCI.
///
/// PCI_USED 0xFF. This IRQ has been assigned to PCI.
///
/// LEGACY_USED 0xFE. This IRQ has been used by an SIO legacy
/// device and cannot be used by PCI.
///
UINT8 Used;
} EFI_LEGACY_IRQ_PRIORITY_TABLE_ENTRY;
//
// Define PIR table structures
//
#define EFI_LEGACY_PIRQ_TABLE_SIGNATURE SIGNATURE_32 ('$', 'P', 'I', 'R')
typedef struct {
///
/// $PIR.
///
UINT32 Signature;
///
/// 0x00.
///
UINT8 MinorVersion;
///
/// 0x01 for table version 1.0.
///
UINT8 MajorVersion;
///
/// 0x20 + RoutingTableEntries * 0x10.
///
UINT16 TableSize;
///
/// PCI interrupt router bus.
///
UINT8 Bus;
///
/// PCI interrupt router device/function.
///
UINT8 DevFun;
///
/// If nonzero, bit map of IRQs reserved for PCI.
///
UINT16 PciOnlyIrq;
///
/// Vendor ID of a compatible PCI interrupt router.
///
UINT16 CompatibleVid;
///
/// Device ID of a compatible PCI interrupt router.
///
UINT16 CompatibleDid;
///
/// If nonzero, a value passed directly to the IRQ miniport's Initialize function.
///
UINT32 Miniport;
///
/// Reserved for future usage.
///
UINT8 Reserved[11];
///
/// This byte plus the sum of all other bytes in the LocalPirqTable equal 0x00.
///
UINT8 Checksum;
} EFI_LEGACY_PIRQ_TABLE_HEADER;
typedef struct {
///
/// If nonzero, a value assigned by the IBV.
///
UINT8 Pirq;
///
/// If nonzero, the IRQs that can be assigned to this device.
///
UINT16 IrqMask;
} EFI_LEGACY_PIRQ_ENTRY;
typedef struct {
///
/// PCI bus of the entry.
///
UINT8 Bus;
///
/// PCI device of this entry.
///
UINT8 Device;
///
/// An IBV value and IRQ mask for PIRQ pins A through D.
///
EFI_LEGACY_PIRQ_ENTRY PirqEntry[4];
///
/// If nonzero, the slot number assigned by the board manufacturer.
///
UINT8 Slot;
///
/// Reserved for future use.
///
UINT8 Reserved;
} EFI_LEGACY_IRQ_ROUTING_ENTRY;
#pragma pack()
/**
Finds the binary data or other platform information.
@param This The protocol instance pointer.
@param Mode Specifies what data to return. See See EFI_GET_PLATFORM_INFO_MODE enum.
@param Table Mode specific. See EFI_GET_PLATFORM_INFO_MODE enum.
@param TableSize Mode specific. See EFI_GET_PLATFORM_INFO_MODE enum.
@param Location Mode specific. See EFI_GET_PLATFORM_INFO_MODE enum.
@param Alignment Mode specific. See EFI_GET_PLATFORM_INFO_MODE enum.
@param LegacySegment Mode specific. See EFI_GET_PLATFORM_INFO_MODE enum.
@param LegacyOffset Mode specific. See EFI_GET_PLATFORM_INFO_MODE enum.
@retval EFI_SUCCESS Data returned successfully.
@retval EFI_UNSUPPORTED Mode is not supported on the platform.
@retval EFI_NOT_FOUND Binary image or table not found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_GET_PLATFORM_INFO)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
IN EFI_GET_PLATFORM_INFO_MODE Mode,
OUT VOID **Table,
OUT UINTN *TableSize,
OUT UINTN *Location,
OUT UINTN *Alignment,
IN UINT16 LegacySegment,
IN UINT16 LegacyOffset
);
/**
Returns a buffer of handles for the requested subfunction.
@param This The protocol instance pointer.
@param Mode Specifies what handle to return. See EFI_GET_PLATFORM_HANDLE_MODE enum.
@param Type Mode specific. See EFI_GET_PLATFORM_HANDLE_MODE enum.
@param HandleBuffer Mode specific. See EFI_GET_PLATFORM_HANDLE_MODE enum.
@param HandleCount Mode specific. See EFI_GET_PLATFORM_HANDLE_MODE enum.
@param AdditionalData Mode specific. See EFI_GET_PLATFORM_HANDLE_MODE enum.
@retval EFI_SUCCESS Handle is valid.
@retval EFI_UNSUPPORTED Mode is not supported on the platform.
@retval EFI_NOT_FOUND Handle is not known.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_GET_PLATFORM_HANDLE)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
IN EFI_GET_PLATFORM_HANDLE_MODE Mode,
IN UINT16 Type,
OUT EFI_HANDLE **HandleBuffer,
OUT UINTN *HandleCount,
IN VOID **AdditionalData OPTIONAL
);
/**
Load and initialize the Legacy BIOS SMM handler.
@param This The protocol instance pointer.
@param EfiToLegacy16BootTable A pointer to Legacy16 boot table.
@retval EFI_SUCCESS SMM code loaded.
@retval EFI_DEVICE_ERROR SMM code failed to load
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_SMM_INIT)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
IN VOID *EfiToLegacy16BootTable
);
/**
Allows platform to perform any required action after a LegacyBios operation.
Invokes the specific sub function specified by Mode.
@param This The protocol instance pointer.
@param Mode Specifies what handle to return. See EFI_GET_PLATFORM_HOOK_MODE enum.
@param Type Mode specific. See EFI_GET_PLATFORM_HOOK_MODE enum.
@param DeviceHandle Mode specific. See EFI_GET_PLATFORM_HOOK_MODE enum.
@param ShadowAddress Mode specific. See EFI_GET_PLATFORM_HOOK_MODE enum.
@param Compatibility16Table Mode specific. See EFI_GET_PLATFORM_HOOK_MODE enum.
@param AdditionalData Mode specific. See EFI_GET_PLATFORM_HOOK_MODE enum.
@retval EFI_SUCCESS The operation performed successfully. Mode specific.
@retval EFI_UNSUPPORTED Mode is not supported on the platform.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_HOOKS)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
IN EFI_GET_PLATFORM_HOOK_MODE Mode,
IN UINT16 Type,
IN EFI_HANDLE DeviceHandle, OPTIONAL
IN OUT UINTN *ShadowAddress, OPTIONAL
IN EFI_COMPATIBILITY16_TABLE *Compatibility16Table, OPTIONAL
OUT VOID **AdditionalData OPTIONAL
);
/**
Returns information associated with PCI IRQ routing.
This function returns the following information associated with PCI IRQ routing:
* An IRQ routing table and number of entries in the table.
* The $PIR table and its size.
* A list of PCI IRQs and the priority order to assign them.
@param This The protocol instance pointer.
@param RoutingTable The pointer to PCI IRQ Routing table.
This location is the $PIR table minus the header.
@param RoutingTableEntries The number of entries in table.
@param LocalPirqTable $PIR table.
@param PirqTableSize $PIR table size.
@param LocalIrqPriorityTable A list of interrupts in priority order to assign.
@param IrqPriorityTableEntries The number of entries in the priority table.
@retval EFI_SUCCESS Data was successfully returned.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_GET_ROUTING_TABLE)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
OUT VOID **RoutingTable,
OUT UINTN *RoutingTableEntries,
OUT VOID **LocalPirqTable, OPTIONAL
OUT UINTN *PirqTableSize, OPTIONAL
OUT VOID **LocalIrqPriorityTable, OPTIONAL
OUT UINTN *IrqPriorityTableEntries OPTIONAL
);
/**
Translates the given PIRQ accounting for bridge.
This function translates the given PIRQ back through all buses, if required,
and returns the true PIRQ and associated IRQ.
@param This The protocol instance pointer.
@param PciBus The PCI bus number for this device.
@param PciDevice The PCI device number for this device.
@param PciFunction The PCI function number for this device.
@param Pirq Input is PIRQ reported by device, and output is true PIRQ.
@param PciIrq The IRQ already assigned to the PIRQ, or the IRQ to be
assigned to the PIRQ.
@retval EFI_SUCCESS The PIRQ was translated.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_TRANSLATE_PIRQ)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
IN UINTN PciBus,
IN UINTN PciDevice,
IN UINTN PciFunction,
IN OUT UINT8 *Pirq,
OUT UINT8 *PciIrq
);
/**
Attempt to legacy boot the BootOption. If the EFI contexted has been
compromised this function will not return.
@param This The protocol instance pointer.
@param BbsDevicePath The EFI Device Path from BootXXXX variable.
@param BbsTable The Internal BBS table.
@param LoadOptionSize The size of LoadOption in size.
@param LoadOption The LoadOption from BootXXXX variable
@param EfiToLegacy16BootTable A pointer to BootTable structure
@retval EFI_SUCCESS Ready to boot.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_PREPARE_TO_BOOT)(
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *This,
IN BBS_BBS_DEVICE_PATH *BbsDevicePath,
IN VOID *BbsTable,
IN UINT32 LoadOptionsSize,
IN VOID *LoadOptions,
IN VOID *EfiToLegacy16BootTable
);
/**
This protocol abstracts the platform portion of the traditional BIOS.
**/
struct _EFI_LEGACY_BIOS_PLATFORM_PROTOCOL {
///
/// Gets binary data or other platform information.
///
EFI_LEGACY_BIOS_PLATFORM_GET_PLATFORM_INFO GetPlatformInfo;
///
/// Returns a buffer of all handles matching the requested subfunction.
///
EFI_LEGACY_BIOS_PLATFORM_GET_PLATFORM_HANDLE GetPlatformHandle;
///
/// Loads and initializes the traditional BIOS SMM handler.
EFI_LEGACY_BIOS_PLATFORM_SMM_INIT SmmInit;
///
/// Allows platform to perform any required actions after a LegacyBios operation.
///
EFI_LEGACY_BIOS_PLATFORM_HOOKS PlatformHooks;
///
/// Gets $PIR table.
EFI_LEGACY_BIOS_PLATFORM_GET_ROUTING_TABLE GetRoutingTable;
///
/// Translates the given PIRQ to the final value after traversing any PCI bridges.
///
EFI_LEGACY_BIOS_PLATFORM_TRANSLATE_PIRQ TranslatePirq;
///
/// Final platform function before the system attempts to boot to a traditional OS.
///
EFI_LEGACY_BIOS_PLATFORM_PREPARE_TO_BOOT PrepareToBoot;
};
extern EFI_GUID gEfiLegacyBiosPlatformProtocolGuid;
#endif

128
IntelFrameworkPkg/Include/Protocol/LegacyInterrupt.h Normal file
View File

@ -0,0 +1,128 @@
/** @file
This protocol abstracts the PIRQ programming from the generic EFI Compatibility Support Modules (CSMs).
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in Framework for the EFI Compatibility Support Module specification.
Version 0.97.
**/
#ifndef _EFI_LEGACY_INTERRUPT_H_
#define _EFI_LEGACY_INTERRUPT_H_
#define EFI_LEGACY_INTERRUPT_PROTOCOL_GUID \
{ \
0x31ce593d, 0x108a, 0x485d, {0xad, 0xb2, 0x78, 0xf2, 0x1f, 0x29, 0x66, 0xbe } \
}
typedef struct _EFI_LEGACY_INTERRUPT_PROTOCOL EFI_LEGACY_INTERRUPT_PROTOCOL;
/**
Get the number of PIRQs this hardware supports.
@param This The protocol instance pointer.
@param NumberPirsq The number of PIRQs that are supported.
@retval EFI_SUCCESS The number of PIRQs was returned successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_GET_NUMBER_PIRQS)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
OUT UINT8 *NumberPirqs
);
/**
Gets the PCI location associated with this protocol.
@param This The Protocol instance pointer.
@param Bus The PCI Bus.
@param Device The PCI Device.
@param Function The PCI Function.
@retval EFI_SUCCESS The Bus, Device, and Function were returned successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_GET_LOCATION)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
OUT UINT8 *Bus,
OUT UINT8 *Device,
OUT UINT8 *Function
);
/**
Read the PIRQ register and return the data
@param This The protocol instance pointer.
@param PirqNumber The PIRQ register to read.
@param PirqData The data read.
@retval EFI_SUCCESS The data was read.
@retval EFI_INVALID_PARAMETER Invalid PIRQ number.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_READ_PIRQ)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
IN UINT8 PirqNumber,
OUT UINT8 *PirqData
);
/**
Write the specified PIRQ register with the given data.
@param This The protocol instance pointer.
@param PirqNumber A PIRQ register to read.
@param PirqData The data to write.
@retval EFI_SUCCESS The PIRQ was programmed.
@retval EFI_INVALID_PARAMETER Invalid PIRQ number.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_WRITE_PIRQ)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
IN UINT8 PirqNumber,
IN UINT8 PirqData
);
struct _EFI_LEGACY_INTERRUPT_PROTOCOL {
///
/// Gets the number of PIRQs supported.
///
EFI_LEGACY_INTERRUPT_GET_NUMBER_PIRQS GetNumberPirqs;
///
/// Gets the PCI bus, device, and function that is associated with this protocol.
///
EFI_LEGACY_INTERRUPT_GET_LOCATION GetLocation;
///
/// Reads the indicated PIRQ register.
///
EFI_LEGACY_INTERRUPT_READ_PIRQ ReadPirq;
///
/// Writes to the indicated PIRQ register.
///
EFI_LEGACY_INTERRUPT_WRITE_PIRQ WritePirq;
};
extern EFI_GUID gEfiLegacyInterruptProtocolGuid;
#endif

125
IntelFrameworkPkg/Include/Protocol/LegacyRegion.h Normal file
View File

@ -0,0 +1,125 @@
/** @file
This protocol manages the legacy memory regions between 0xc0000 - 0xfffff.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.97.
**/
#ifndef _EFI_LEGACY_REGION_H_
#define _EFI_LEGACY_REGION_H_
#define EFI_LEGACY_REGION_PROTOCOL_GUID \
{ \
0xfc9013a, 0x568, 0x4ba9, {0x9b, 0x7e, 0xc9, 0xc3, 0x90, 0xa6, 0x60, 0x9b } \
}
typedef struct _EFI_LEGACY_REGION_PROTOCOL EFI_LEGACY_REGION_PROTOCOL;
/**
Sets hardware to decode or not decode a region.
@param This Indicates the EFI_LEGACY_REGION_PROTOCOL instance
@param Start The start of the region to decode.
@param Length The size in bytes of the region.
@param On The decode/nondecode flag.
@retval EFI_SUCCESS The decode range successfully changed.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_DECODE)(
IN EFI_LEGACY_REGION_PROTOCOL *This,
IN UINT32 Start,
IN UINT32 Length,
IN BOOLEAN *On
);
/**
Sets a region to read only.
@param This Indicates the EFI_LEGACY_REGION_PROTOCOL instance.
@param Start The start of region to lock.
@param Length The size in bytes of the region.
@param Granularity Lock attribute affects this granularity in bytes.
@retval EFI_SUCCESS The region was made read only.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_LOCK)(
IN EFI_LEGACY_REGION_PROTOCOL *This,
IN UINT32 Start,
IN UINT32 Length,
OUT UINT32 *Granularity OPTIONAL
);
/**
Sets a region to read only and ensures that flash is locked from being
inadvertently modified.
@param This Indicates the EFI_LEGACY_REGION_PROTOCOL instance
@param Start The start of region to lock.
@param Length The size in bytes of the region.
@param Granularity Lock attribute affects this granularity in bytes.
@retval EFI_SUCCESS The region was made read only and flash is locked.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_BOOT_LOCK)(
IN EFI_LEGACY_REGION_PROTOCOL *This,
IN UINT32 Start,
IN UINT32 Length,
OUT UINT32 *Granularity OPTIONAL
);
/**
Sets a region to read-write.
@param This Indicates the EFI_LEGACY_REGION_PROTOCOL instance
@param Start The start of region to lock.
@param Length The size in bytes of the region.
@param Granularity Lock attribute affects this granularity in bytes.
@retval EFI_SUCCESS The region was successfully made read-write.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_UNLOCK)(
IN EFI_LEGACY_REGION_PROTOCOL *This,
IN UINT32 Start,
IN UINT32 Length,
OUT UINT32 *Granularity OPTIONAL
);
/**
Abstracts the hardware control of the physical address region 0xC0000-C0xFFFFF
for the traditional BIOS.
**/
struct _EFI_LEGACY_REGION_PROTOCOL {
EFI_LEGACY_REGION_DECODE Decode; ///< Specifies a region for the chipset to decode.
EFI_LEGACY_REGION_LOCK Lock; ///< Makes the specified OpROM region read only or locked.
EFI_LEGACY_REGION_BOOT_LOCK BootLock; ///< Sets a region to read only and ensures tat flash is locked from.
///< inadvertent modification.
EFI_LEGACY_REGION_UNLOCK UnLock; ///< Makes the specified OpROM region read-write or unlocked.
};
extern EFI_GUID gEfiLegacyRegionProtocolGuid;
#endif

161
IntelFrameworkPkg/Include/Protocol/SectionExtraction.h Normal file
View File

@ -0,0 +1,161 @@
/** @file
This file declares Section Extraction Protocol.
This interface provides a means of decoding a set of sections into a linked list of
leaf sections. This provides for an extensible and flexible file format.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This protocol is defined in Firmware Volume Specification.
Version 0.9.
**/
#ifndef _SECTION_EXTRACTION_PROTOCOL_H_
#define _SECTION_EXTRACTION_PROTOCOL_H_
//
// Protocol GUID definition
//
#define EFI_SECTION_EXTRACTION_PROTOCOL_GUID \
{ \
0x448F5DA4, 0x6DD7, 0x4FE1, {0x93, 0x07, 0x69, 0x22, 0x41, 0x92, 0x21, 0x5D } \
}
typedef struct _EFI_SECTION_EXTRACTION_PROTOCOL EFI_SECTION_EXTRACTION_PROTOCOL;
//
// Protocol member functions
//
/**
Creates and returns a new section stream handle to represent the new section stream.
@param This Indicates the EFI_SECTION_EXTRACTION_PROTOCOL instance.
@param SectionStreamLength The size in bytes of the section stream.
@param SectionStream A buffer containing the new section stream.
@param SectionStreamHandle A pointer to a caller-allocated UINTN that,
on output, contains the new section stream handle.
@retval EFI_SUCCESS The SectionStream was successfully processed, and
the section stream handle was returned.
@retval EFI_OUT_OF_RESOURCES The system has insufficient resources to
process the request.
@retval EFI_INVALID_PARAMETER The section stream may be corrupt or the value
of SectionStreamLength may be incorrect.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_OPEN_SECTION_STREAM)(
IN EFI_SECTION_EXTRACTION_PROTOCOL *This,
IN UINTN SectionStreamLength,
IN VOID *SectionStream,
OUT UINTN *SectionStreamHandle
);
/**
Reads and returns a single section from a section stream.
@param This Indicates the EFI_SECTION_EXTRACTION_PROTOCOL instance.
@param SectionStreamHandle Indicates from which section stream to read.
@param SectionType The pointer to an EFI_SECTION_TYPE. If SectionType == NULL,
the contents of the entire section stream are returned
in Buffer. If SectionType is not NULL, only the
requested section is returned. EFI_SECTION_ALL
matches all section types and can be used as a
wild card to extract all sections in order.
@param SectionDefinitionGuid The pointer to an EFI_GUID. If SectionType ==
EFI_SECTION_GUID_DEFINED, SectionDefinitionGuid
indicates what section GUID to search for. If
SectionType !=EFI_SECTION_GUID_DEFINED, then
SectionDefinitionGuid is unused and is ignored.
@param SectionInstance Indicates which instance of the requested section
type to return when SectionType is not NULL.
@param SectionStreamHandle A pointer to a caller-allocated UINTN that, on output,
contains the new section stream handle.
@param Buffer Pointer to a pointer to a buffer in which the section
contents are returned.
@param BufferSize A pointer to a caller-allocated UINTN.
@param AuthenticationStatus A pointer to a caller-allocated UINT32 in
which any meta-data from encapsulation GUID-defined
sections is returned.
@retval EFI_SUCCESS The SectionStream was successfully processed and
the section contents were returned in Buffer.
@retval EFI_PROTOCOL_ERROR A GUID-defined section was encountered inthe section
stream with its EFI_GUIDED_SECTION_PROCESSING_REQUIRED
bit set, but there was no corresponding GUIDed
Section Extraction Protocol in the handle database.
@retval EFI_NOT_FOUND An error was encountered when parsing the SectionStream,
which indicates that the SectionStream is not
correctly formatted. Or, the requested section does not exist.
@retval EFI_OUT_OF_RESOURCES The system has insufficient resources to process
the request.
@retval EFI_INVALID_PARAMETER The SectionStreamHandle does not exist.
@retval EFI_WARN_BUFFER_TOO_SMALL The size of the input buffer is insufficient
to contain the requested section. The input
buffer is filled and section contents are truncated.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_GET_SECTION)(
IN EFI_SECTION_EXTRACTION_PROTOCOL *This,
IN UINTN SectionStreamHandle,
IN EFI_SECTION_TYPE *SectionType,
IN EFI_GUID *SectionDefinitionGuid,
IN UINTN SectionInstance,
IN VOID **Buffer,
IN OUT UINTN *BufferSize,
OUT UINT32 *AuthenticationStatus
);
/**
Deletes a section stream handle and returns all associated resources to the system.
@param This Indicates the EFI_SECTION_EXTRACTION_PROTOCOL instance.
@param SectionStreamHandle Indicates the section stream to close.
@retval EFI_SUCCESS The SectionStream was successfully processed and
the section stream handle was returned.
@retval EFI_INVALID_PARAMETER The SectionStreamHandle does not exist.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_CLOSE_SECTION_STREAM)(
IN EFI_SECTION_EXTRACTION_PROTOCOL *This,
IN UINTN SectionStreamHandle
);
//
// Protocol definition
//
struct _EFI_SECTION_EXTRACTION_PROTOCOL {
///
/// Takes a bounded stream of sections and returns a section stream handle.
///
EFI_OPEN_SECTION_STREAM OpenSectionStream;
///
/// Given a section stream handle, retrieves the requested section and
/// meta-data from the section stream.
///
EFI_GET_SECTION GetSection;
///
/// Given a section stream handle, closes the section stream.
///
EFI_CLOSE_SECTION_STREAM CloseSectionStream;
};
extern EFI_GUID gEfiSectionExtractionProtocolGuid;
#endif

130
IntelFrameworkPkg/Include/Protocol/SmmAccess.h Normal file
View File

@ -0,0 +1,130 @@
/** @file
This file declares the SMM SMRAM Access abstraction protocol, which is used to control
the visibility of the SMRAM on the platform. The expectation is
that the north bridge or memory controller would publish this protocol.
For example, the Memory Controller Hub (MCH) has the hardware provision for this
type of control. Because of the protected, distinguished class of memory for IA-32
systems, the expectation is that this protocol would be supported only on IA-32 systems.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _SMM_ACCESS_H_
#define _SMM_ACCESS_H_
#include <Guid/SmramMemoryReserve.h>
typedef struct _EFI_SMM_ACCESS_PROTOCOL EFI_SMM_ACCESS_PROTOCOL;
#define EFI_SMM_ACCESS_PROTOCOL_GUID \
{ \
0x3792095a, 0xe309, 0x4c1e, {0xaa, 0x01, 0x85, 0xf5, 0x65, 0x5a, 0x17, 0xf1 } \
}
//
// SMM Access specification Member Function
//
/**
Opens the SMRAM area to be accessible by a boot-service driver.
@param This The EFI_SMM_ACCESS_PROTOCOL instance.
@param DescriptorIndex Indicates that the driver wishes to open
the memory tagged by this index.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_INVALID_PARAMETER The given DescriptorIndex is not supported.
@retval EFI_NOT_STARTED The SMM base service has not been initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_OPEN)(
IN EFI_SMM_ACCESS_PROTOCOL *This,
UINTN DescriptorIndex
);
/**
Inhibits access to the SMRAM.
@param This The EFI_SMM_ACCESS_PROTOCOL instance.
@param DescriptorIndex Indicates that the driver wishes to close
the memory tagged by this index.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_DEVICE_ERROR The given DescriptorIndex is not open.
@retval EFI_INVALID_PARAMETER The given DescriptorIndex is not supported.
@retval EFI_NOT_STARTED The SMM base service has not been initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CLOSE)(
IN EFI_SMM_ACCESS_PROTOCOL *This,
UINTN DescriptorIndex
);
/**
Inhibits access to the SMRAM.
@param This The EFI_SMM_ACCESS_PROTOCOL instance.
@param DescriptorIndex Indicates that the driver wishes to lock
the memory tagged by this index.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_DEVICE_ERROR The given DescriptorIndex is not open.
@retval EFI_INVALID_PARAMETER The given DescriptorIndex is not supported.
@retval EFI_NOT_STARTED The SMM base service has not been initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_LOCK)(
IN EFI_SMM_ACCESS_PROTOCOL *This,
UINTN DescriptorIndex
);
/**
Queries the memory controller for the possible regions that will support SMRAM.
@param This The EFI_SMM_ACCESS_PROTOCOL instance.
@param SmramMapSize A pointer to the size, in bytes, of the SmramMemoryMap buffer.
@param SmramMap A pointer to the buffer in which firmware places the current memory map.
@retval EFI_SUCCESS The chipset supported the given resource.
@retval EFI_BUFFER_TOO_SMALL The SmramMap parameter was too small.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CAPABILITIES)(
IN EFI_SMM_ACCESS_PROTOCOL *This,
IN OUT UINTN *SmramMapSize,
IN OUT EFI_SMRAM_DESCRIPTOR *SmramMap
);
/**
This protocol is used to control the visibility of the SMRAM on the platform.
**/
struct _EFI_SMM_ACCESS_PROTOCOL {
EFI_SMM_OPEN Open; ///< Opens the SMRAM.
EFI_SMM_CLOSE Close; ///< Closes the SMRAM.
EFI_SMM_LOCK Lock; ///< Locks the SMRAM.
EFI_SMM_CAPABILITIES GetCapabilities; ///< Gets information on possible SMRAM regions.
BOOLEAN LockState; ///< Indicates the current state of the SMRAM. Set to TRUE if any region is locked.
BOOLEAN OpenState; ///< Indicates the current state of the SMRAM. Set to TRUE if any region is open.
};
extern EFI_GUID gEfiSmmAccessProtocolGuid;
#endif

310
IntelFrameworkPkg/Include/Protocol/SmmBase.h Normal file
View File

@ -0,0 +1,310 @@
/** @file
This file declares SMM Base abstraction protocol.
This protocol is used to install SMM handlers for support of subsequent SMI/PMI activations. This
protocol is available on both IA-32 and Itanium-based systems.
The EFI_SMM_BASE_PROTOCOL is a set of services that is exported by a processor device. It is
a required protocol for the platform processor. This protocol can be used in both boot services and
runtime mode. However, only the following member functions need to exist during runtime:
- InSmm()
- Communicate()
This protocol is responsible for registering the handler services. The order in which the handlers are
executed is prescribed only with respect to the MakeLast flag in the RegisterCallback()
service. The driver exports these registration and unregistration services in boot services mode, but
the registered handlers will execute through the preboot and runtime. The only way to change the
behavior of a registered driver after ExitBootServices() has been invoked is to use some
private communication mechanism with the driver to order it to quiesce. This model permits typical
use cases, such as invoking the handler to enter ACPI mode, where the OS loader would make this
call before boot services are terminated. On the other hand, handlers for services such as chipset
workarounds for the century rollover in CMOS should provide commensurate services throughout
preboot and OS runtime.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _SMM_BASE_H_
#define _SMM_BASE_H_
//
// Share some common definitions with PI SMM
//
#include <Framework/SmmCis.h>
#include <Protocol/SmmCommunication.h>
///
/// Global ID for the EFI_SMM_BASE_PROTOCOL.
///
#define EFI_SMM_BASE_PROTOCOL_GUID \
{ \
0x1390954D, 0xda95, 0x4227, {0x93, 0x28, 0x72, 0x82, 0xc2, 0x17, 0xda, 0xa8 } \
}
///
/// Forward declaration for EFI_SMM_BASE_PROTOCOL.
///
typedef struct _EFI_SMM_BASE_PROTOCOL EFI_SMM_BASE_PROTOCOL;
///
/// EFI SMM Handler return codes
///
///@{
#define EFI_HANDLER_SUCCESS 0x0000
#define EFI_HANDLER_CRITICAL_EXIT 0x0001
#define EFI_HANDLER_SOURCE_QUIESCED 0x0002
#define EFI_HANDLER_SOURCE_PENDING 0x0003
///@}
/**
Entry Point to Callback service
@param[in] SmmImageHandle A handle allocated by the SMM infrastructure code
to uniquely designate a specific DXE SMM driver.
@param[in] CommunicationBuffer A pointer to a collection of data in memory
that will be conveyed from a non-SMM environment
into an SMM environment. The buffer must be
contiguous and physically mapped, and must be
a physical address.
@param[in] SourceSize The size of the CommunicationBuffer.
@return Status code
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CALLBACK_ENTRY_POINT)(
IN EFI_HANDLE SmmImageHandle,
IN OUT VOID *CommunicationBuffer OPTIONAL,
IN OUT UINTN *SourceSize OPTIONAL
);
//
// SMM Base Protocol Definition
//
/**
Register a given driver into SMRAM. This is the equivalent of performing
the LoadImage/StartImage into System Management Mode.
@param[in] This The protocol instance pointer.
@param[in] FilePath The location of the image to be installed as the handler.
@param[in] SourceBuffer An optional source buffer in case the image file
is in memory.
@param[in] SourceSize The size of the source image file, if in memory.
@param[out] ImageHandle The handle that the base driver uses to decode
the handler. Unique among SMM handlers only;
not unique across DXE/EFI.
@param[in] LegacyIA32Binary An optional parameter specifying that the associated
file is a real-mode IA-32 binary.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_OUT_OF_RESOURCES There were no additional SMRAM resources to load the handler
@retval EFI_UNSUPPORTED This platform does not support 16-bit handlers.
@retval EFI_UNSUPPORTED The platform is in runtime.
@retval EFI_INVALID_PARAMETER The handlers were not the correct image type.
**/
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
);
/**
Removes a handler from execution within SMRAM. This is the equivalent of performing
the UnloadImage in System Management Mode.
@param[in] This The protocol instance pointer.
@param[in] ImageHandle The handler to be removed.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_INVALID_PARAMETER The handler did not exist.
@retval EFI_UNSUPPORTED The platform is in runtime.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_UNREGISTER_HANDLER)(
IN EFI_SMM_BASE_PROTOCOL *This,
IN EFI_HANDLE ImageHandle
);
/**
The SMM Inter-module Communicate Service Communicate() function
provides a service to send/receive 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.
@param[in] This The protocol instance pointer.
@param[in] ImageHandle The handle of the registered driver.
@param[in,out] CommunicationBuffer The pointer to the buffer to convey into SMRAM.
@param[in,out] SourceSize 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 buffer was NULL.
**/
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
);
/**
Register a callback to execute within SMM.
This allows receipt of messages created with EFI_SMM_BASE_PROTOCOL.Communicate().
@param[in] This Protocol instance pointer.
@param[in] SmmImageHandle Handle of the callback service.
@param[in] CallbackAddress Address of the callback service.
@param[in] MakeLast If present, will stipulate that the handler is posted to
be executed last in the dispatch table.
@param[in] FloatingPointSave An optional parameter that informs the
EFI_SMM_ACCESS_PROTOCOL Driver core if it needs to save
the floating point register state. If any handler
require this, the state will be saved for all handlers.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_OUT_OF_RESOURCES Not enough space in the dispatch queue.
@retval EFI_UNSUPPORTED The platform is in runtime.
@retval EFI_UNSUPPORTED The caller is not in SMM.
**/
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
);
/**
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.
@param[in] This Protocol instance pointer.
@param[in] PoolType The type of pool to allocate.
The only supported type is EfiRuntimeServicesData;
the interface will internally map this runtime request to
SMRAM for IA-32 and leave as this type for the Itanium
processor family. Other types can be ignored.
@param[in] Size The number of bytes to allocate from the pool.
@param[out] Buffer A pointer to a pointer to the allocated buffer if the call
succeeds; undefined otherwise.
@retval EFI_SUCCESS The requested number of bytes was allocated.
@retval EFI_OUT_OF_RESOURCES The pool requested could not be allocated.
@retval EFI_UNSUPPORTED The platform is in runtime.
**/
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
);
/**
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().
@param[in] This The protocol instance pointer.
@param[in] Buffer The pointer to the buffer allocation.
@retval EFI_SUCCESS The memory was returned to the system.
@retval EFI_INVALID_PARAMETER The buffer was invalid.
@retval EFI_UNSUPPORTED The platform is in runtime.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_FREE_POOL)(
IN EFI_SMM_BASE_PROTOCOL *This,
IN VOID *Buffer
);
/**
This routine tells caller if execution context is SMM or not.
@param[in] This The protocol instance pointer.
@param[out] InSmm Whether the caller is inside SMM for IA-32
or servicing a PMI for the Itanium processor
family.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_INVALID_PARAMETER InSmm was NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INSIDE_OUT)(
IN EFI_SMM_BASE_PROTOCOL *This,
OUT BOOLEAN *InSmm
);
/**
The GetSmstLocation() function returns the location 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.
@param[in] This The protocol instance pointer.
@param[in] Smst The pointer to the SMST.
@retval EFI_SUCCESS The operation was successful
@retval EFI_INVALID_PARAMETER Smst was invalid.
@retval EFI_UNSUPPORTED Not in SMM.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GET_SMST_LOCATION)(
IN EFI_SMM_BASE_PROTOCOL *This,
IN OUT EFI_SMM_SYSTEM_TABLE **Smst
);
///
/// This protocol is used to install SMM handlers for support of subsequent SMI/PMI
/// activations. This protocol is available on both IA-32 and Itanium-based systems.
///
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;
};
extern EFI_GUID gEfiSmmBaseProtocolGuid;
#endif

180
IntelFrameworkPkg/Include/Protocol/SmmControl.h Normal file
View File

@ -0,0 +1,180 @@
/** @file
This file declares the SMM Control abstraction protocol.
This protocol is used to initiate SMI/PMI activations. This protocol could be published by either:
- A processor driver to abstract the SMI/PMI IPI
- The driver that abstracts the ASIC that is supporting the APM port, such as the ICH in an
Intel chipset
Because of the possibility of performing SMI or PMI IPI transactions, the ability to generate this
event from a platform chipset agent is an optional capability for both IA-32 and Itanium-based
systems.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _SMM_CONTROL_H_
#define _SMM_CONTROL_H_
typedef struct _EFI_SMM_CONTROL_PROTOCOL EFI_SMM_CONTROL_PROTOCOL;
#define EFI_SMM_CONTROL_PROTOCOL_GUID \
{ \
0x8d12e231, 0xc667, 0x4fd1, {0x98, 0xf2, 0x24, 0x49, 0xa7, 0xe7, 0xb2, 0xe5 } \
}
//
// SMM Access specification Data Structures
//
typedef struct {
///
/// Describes the I/O location of the particular port that engendered the synchronous
/// SMI. For example, this location can include but is not limited to the traditional
/// PCAT* APM port of 0B2h.
///
UINT8 SmiTriggerRegister;
///
/// Describes the value that was written to the respective activation port.
///
UINT8 SmiDataRegister;
} EFI_SMM_CONTROL_REGISTER;
//
// SMM Control specification member function
//
/**
Invokes SMI activation from either the preboot or runtime environment.
@param This The EFI_SMM_CONTROL_PROTOCOL instance.
@param ArgumentBuffer The optional sized data to pass into the protocol activation.
@param ArgumentBufferSize The optional size of the data.
@param Periodic An optional mechanism to periodically repeat activation.
@param ActivationInterval An optional parameter to repeat at this period one
time or, if the Periodic Boolean is set, periodically.
@retval EFI_SUCCESS The SMI/PMI has been engendered.
@retval EFI_DEVICE_ERROR The timing is unsupported.
@retval EFI_INVALID_PARAMETER The activation period is unsupported.
@retval EFI_NOT_STARTED The SMM base service has not been initialized.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ACTIVATE)(
IN EFI_SMM_CONTROL_PROTOCOL *This,
IN OUT INT8 *ArgumentBuffer OPTIONAL,
IN OUT UINTN *ArgumentBufferSize OPTIONAL,
IN BOOLEAN Periodic OPTIONAL,
IN UINTN ActivationInterval OPTIONAL
);
/**
Clears any system state that was created in response to the Active call.
@param This The EFI_SMM_CONTROL_PROTOCOL instance.
@param Periodic Optional parameter to repeat at this period one
time or, if the Periodic Boolean is set, periodically.
@retval EFI_SUCCESS The SMI/PMI has been engendered.
@retval EFI_DEVICE_ERROR The source could not be cleared.
@retval EFI_INVALID_PARAMETER The service did not support the Periodic input argument.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_DEACTIVATE)(
IN EFI_SMM_CONTROL_PROTOCOL *This,
IN BOOLEAN Periodic OPTIONAL
);
/**
Provides information on the source register used to generate the SMI.
@param This The EFI_SMM_CONTROL_PROTOCOL instance.
@param SmiRegister A pointer to the SMI register description structure.
@retval EFI_SUCCESS The register structure has been returned.
@retval EFI_DEVICE_ERROR The source could not be cleared.
@retval EFI_INVALID_PARAMETER The service did not support the Periodic input argument.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GET_REGISTER_INFO)(
IN EFI_SMM_CONTROL_PROTOCOL *This,
IN OUT EFI_SMM_CONTROL_REGISTER *SmiRegister
);
/**
@par Protocol Description:
This protocol is used to initiate SMI/PMI activations.
@param Trigger
Initiates the SMI/PMI activation.
@param Clear
Quiesces the SMI/PMI activation.
@param GetRegisterInfo
Provides data on the register used as the source of the SMI.
@param MinimumTriggerPeriod
Minimum interval at which the platform can set the period.
@retval EFI_SUCCESS The register structure has been returned.
**/
//
// SMM Control Protocol
//
/**
This protocol is used to initiate SMI/PMI activations.
This protocol could be published by either:
- A processor driver to abstract the SMI/PMI IPI.
- The driver that abstracts the ASIC that is supporting the APM port, such as the ICH in an Intel chipset.
Because of the possibility of performing SMI or PMI IPI transactions, the ability to generate this.
The EFI_SMM_CONTROL_PROTOCOL is used by the platform chipset or processor driver. This
protocol is usable both in boot services and at runtime. The runtime aspect enables an
implementation of EFI_SMM_BASE_PROTOCOL.Communicate() to layer upon this service
and provide an SMI callback from a general EFI runtime driver.
This protocol provides an abstraction to the platform hardware that generates an
SMI or PMI. There are often I/O ports that, when accessed, will engender the SMI or PMI.
Also, this hardware optionally supports the periodic genearation of these signals.
**/
struct _EFI_SMM_CONTROL_PROTOCOL {
///
/// Initiates the SMI/PMI activation.
///
EFI_SMM_ACTIVATE Trigger;
///
/// Quiesces the SMI/PMI activation.
///
EFI_SMM_DEACTIVATE Clear;
///
/// Provides data on the register used as the source of the SMI.
///
EFI_SMM_GET_REGISTER_INFO GetRegisterInfo;
///
/// Minimum interval at which the platform can set the period. A maximum is not
/// specified in that the SMM infrastructure code can emulate a maximum interval that is
/// greater than the hardware capabilities by using software emulation in the SMM
/// infrastructure code.
///
UINTN MinimumTriggerPeriod;
};
extern EFI_GUID gEfiSmmControlProtocolGuid;
#endif

88
IntelFrameworkPkg/Include/Protocol/SmmCpuIo.h Normal file
View File

@ -0,0 +1,88 @@
/** @file
SMM CPU I/O protocol as defined in the Intel Framework specification.
This protocol provides CPU I/O and memory access within SMM.
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _SMM_CPU_IO_H_
#define _SMM_CPU_IO_H_
#include <Protocol/SmmCpuIo2.h>
#define EFI_SMM_CPU_IO_GUID \
{ \
0x5f439a0b, 0x45d8, 0x4682, {0xa4, 0xf4, 0xf0, 0x57, 0x6b, 0x51, 0x34, 0x41} \
}
typedef struct _EFI_SMM_CPU_IO_INTERFACE EFI_SMM_CPU_IO_INTERFACE;
/**
Provides the basic memory and I/O interfaces used to abstract 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_SMM_CPU_IO_INTERFACE instance.
@param[in] Width Signifies the width of the I/O operations.
@param[in] Address The base address of the I/O operations. The caller is
responsible for aligning the Address, if required.
@param[in] Count The number of I/O operations to perform.
@param[in,out] Buffer For read operations, the destination buffer to store
the results. For write operations, the source buffer
from which to write data.
@retval EFI_SUCCESS The data was read from or written to the device.
@retval EFI_UNSUPPORTED The Address is not valid for this system.
@retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid.
@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack
of resources.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CPU_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 {
///
/// This service provides the various modalities of memory and I/O read.
///
EFI_SMM_CPU_IO Read;
///
/// This service provides the various modalities of memory and I/O write.
///
EFI_SMM_CPU_IO Write;
} EFI_SMM_IO_ACCESS;
///
/// SMM CPU I/O Protocol provides CPU I/O and memory access within SMM.
///
struct _EFI_SMM_CPU_IO_INTERFACE {
///
/// Allows reads and writes to memory-mapped I/O space.
///
EFI_SMM_IO_ACCESS Mem;
///
/// Allows reads and writes to I/O space.
///
EFI_SMM_IO_ACCESS Io;
};
extern EFI_GUID gEfiSmmCpuIoGuid;
#endif

175
IntelFrameworkPkg/Include/Protocol/SmmCpuSaveState.h Normal file
View File

@ -0,0 +1,175 @@
/** @file
This file declares the SMM CPU Save State protocol, which provides the processor
save-state information for IA-32 and Itanium processors.
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.91.
**/
#ifndef _SMM_CPU_SAVE_STATE_H_
#define _SMM_CPU_SAVE_STATE_H_
#define EFI_SMM_CPU_SAVE_STATE_PROTOCOL_GUID \
{ \
0x21f302ad, 0x6e94, 0x471b, {0x84, 0xbc, 0xb1, 0x48, 0x0, 0x40, 0x3a, 0x1d} \
}
typedef struct _EFI_SMM_CPU_SAVE_STATE_PROTOCOL EFI_SMM_CPU_SAVE_STATE_PROTOCOL;
#define EFI_SMM_MIN_REV_ID_x64 0x30006
#pragma pack (1)
///
/// CPU save-state strcuture for IA32 and X64.
///
/// This struct declaration does not exctly match the Framework SMM CIS 0.91 because the
/// union in the Framework SMM CIS 0.91 contains an unnamed union member that causes build
/// breaks on many compilers with high warning levels. Instead, the UINT8 Reserved[0x200]
/// field has been moved into EFI_SMM_CPU_STATE32. This maintains binary compatibility for
/// the layout and also maintains source comaptibility for access of all fields in this
/// union.
///
/// This struct declaration does not exctly match the Framework SMM CIS 0.91 because
/// the Framework SMM CIS 0.91 uses ASM_XXX for base types in this structure. These
/// have been changed to use the base types defined in the UEFI Specification.
///
typedef struct {
UINT8 Reserved[0x200];
UINT8 Reserved1[0xf8]; // fe00h
UINT32 SMBASE; // fef8h
UINT32 SMMRevId; // fefch
UINT16 IORestart; // ff00h
UINT16 AutoHALTRestart; // ff02h
UINT32 IEDBASE; // ff04h
UINT8 Reserved2[0x98]; // ff08h
UINT32 IOMemAddr; // ffa0h
UINT32 IOMisc; // ffa4h
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_STATE32;
///
/// This struct declaration does not exctly match the Framework SMM CIS 0.91 because
/// the Framework SMM CIS 0.91 uses ASM_XXX for base types in this structure. These
/// have been changed to use the base types defined in the UEFI Specification.
///
typedef struct {
UINT8 Reserved1[0x1d0]; // fc00h
UINT32 GdtBaseHiDword; // fdd0h
UINT32 LdtBaseHiDword; // fdd4h
UINT32 IdtBaseHiDword; // fdd8h
UINT8 Reserved2[0xc]; // fddch
UINT64 IO_EIP; // fde8h
UINT8 Reserved3[0x50]; // fdf0h
UINT32 _CR4; // fe40h
UINT8 Reserved4[0x48]; // fe44h
UINT32 GdtBaseLoDword; // fe8ch
UINT32 GdtLimit; // fe90h
UINT32 IdtBaseLoDword; // fe94h
UINT32 IdtLimit; // fe98h
UINT32 LdtBaseLoDword; // fe9ch
UINT32 LdtLimit; // fea0h
UINT32 LdtInfo; // fea4h
UINT8 Reserved5[0x50]; // fea8h
UINT32 SMBASE; // fef8h
UINT32 SMMRevId; // fefch
UINT16 AutoHALTRestart; // ff00h
UINT16 IORestart; // ff02h
UINT32 IEDBASE; // ff04h
UINT8 Reserved6[0x14]; // ff08h
UINT64 _R15; // ff1ch
UINT64 _R14;
UINT64 _R13;
UINT64 _R12;
UINT64 _R11;
UINT64 _R10;
UINT64 _R9;
UINT64 _R8;
UINT64 _RAX; // ff5ch
UINT64 _RCX;
UINT64 _RDX;
UINT64 _RBX;
UINT64 _RSP;
UINT64 _RBP;
UINT64 _RSI;
UINT64 _RDI;
UINT64 IOMemAddr; // ff9ch
UINT32 IOMisc; // ffa4h
UINT32 _ES; // ffa8h
UINT32 _CS;
UINT32 _SS;
UINT32 _DS;
UINT32 _FS;
UINT32 _GS;
UINT32 _LDTR; // ffc0h
UINT32 _TR;
UINT64 _DR7; // ffc8h
UINT64 _DR6;
UINT64 _RIP; // ffd8h
UINT64 IA32_EFER; // ffe0h
UINT64 _RFLAGS; // ffe8h
UINT64 _CR3; // fff0h
UINT64 _CR0; // fff8h
} EFI_SMM_CPU_STATE64;
///
/// Union of CPU save-state strcutures for IA32 and X64.
///
/// This union declaration does not exctly match the Framework SMM CIS 0.91 because the
/// union in the Framework SMM CIS 0.91 contains an unnamed union member that causes build
/// breaks on many compilers with high warning levels. Instead, the UINT8 Reserved[0x200]
/// field has been moved into EFI_SMM_CPU_STATE32. This maintains binary compatibility for
/// the layout and also maintains source comaptibility for access of all fields in this
/// union.
///
typedef union {
EFI_SMM_CPU_STATE32 x86;
EFI_SMM_CPU_STATE64 x64;
} EFI_SMM_CPU_STATE;
#pragma pack ()
///
/// Provides a programatic means to access SMM save state.
///
struct _EFI_SMM_CPU_SAVE_STATE_PROTOCOL {
///
/// Reference to a list of save states.
///
EFI_SMM_CPU_STATE **CpuSaveState;
};
extern EFI_GUID gEfiSmmCpuSaveStateProtocolGuid;
#endif

136
IntelFrameworkPkg/Include/Protocol/SmmGpiDispatch.h Normal file
View File

@ -0,0 +1,136 @@
/** @file
This file declares the Smm Gpi Smi Child Protocol.
The EFI_SMM_GPI_DISPATCH_PROTOCOL is defined in Framework of EFI SMM Core Interface Spec
Version 0.9. It provides the ability to install child handlers for the given event types.
Several inputs can be enabled. This purpose of this interface is to generate an
SMI in response to any of these inputs having a true value provided.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _SMM_GPI_DISPATCH_H_
#define _SMM_GPI_DISPATCH_H_
//
// Global ID for the GPI SMI Protocol
//
#define EFI_SMM_GPI_DISPATCH_PROTOCOL_GUID \
{ \
0xe0744b81, 0x9513, 0x49cd, {0x8c, 0xea, 0xe9, 0x24, 0x5e, 0x70, 0x39, 0xda } \
}
typedef struct _EFI_SMM_GPI_DISPATCH_PROTOCOL EFI_SMM_GPI_DISPATCH_PROTOCOL;
//
// Related Definitions
//
//
// GpiMask is a bit mask of 32 possible general purpose inputs that can generate
// an SMI. Bit 0 corresponds to logical GPI[0], 1 corresponds to logical GPI[1], and so on.
//
// The logical GPI index to physical pin on device is described by the GPI device name
// found on the same handle as the GpiSmi child dispatch protocol. The GPI device name
// is defined as protocol with a GUID name and NULL protocol pointer.
//
typedef struct {
UINTN GpiNum;
} EFI_SMM_GPI_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a GPI SMI handler.
@param DispatchHandle The handle of this dispatch function.
@param DispatchContext The pointer to the dispatch function's context.
The DispatchContext fields are filled in by the
dispatching driver prior to invoking this dispatch
function.
**/
typedef
VOID
(EFIAPI *EFI_SMM_GPI_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_GPI_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver
@param This The pointer to the EFI_SMM_GPI_DISPATCH_PROTOCOL instance.
@param DispatchFunction Function to install.
@param DispatchContext The pointer to the dispatch function's context.
Indicates to the register
function the GPI(s) for which the dispatch function
should be invoked.
@param DispatchHandle The handle generated by the dispatcher to track the
function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered, and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The GPI input value
is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GPI_REGISTER)(
IN EFI_SMM_GPI_DISPATCH_PROTOCOL *This,
IN EFI_SMM_GPI_DISPATCH DispatchFunction,
IN EFI_SMM_GPI_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a General Purpose Input (GPI) service.
@param This The pointer to the EFI_SMM_GPI_DISPATCH_PROTOCOL instance.
@param DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered, and the SMI source has been disabled,
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER DispatchHandle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GPI_UNREGISTER)(
IN EFI_SMM_GPI_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM GPI SMI Dispatch Protocol
//
struct _EFI_SMM_GPI_DISPATCH_PROTOCOL {
EFI_SMM_GPI_REGISTER Register;
EFI_SMM_GPI_UNREGISTER UnRegister;
///
/// Denotes the maximum value of inputs that can have handlers attached.
///
UINTN NumSupportedGpis;
};
extern EFI_GUID gEfiSmmGpiDispatchProtocolGuid;
#endif

189
IntelFrameworkPkg/Include/Protocol/SmmIchnDispatch.h Normal file
View File

@ -0,0 +1,189 @@
/** @file
Provides the parent dispatch service for a given SMI source generator.
The EFI_SMM_ICHN_DISPATCH_PROTOCOL provides the ability to install child handlers for
the given event types.
Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_ICHN_DISPATCH_H_
#define _EFI_SMM_ICHN_DISPATCH_H_
//
// Global ID for the ICH SMI Protocol
//
#define EFI_SMM_ICHN_DISPATCH_PROTOCOL_GUID \
{ \
0xc50b323e, 0x9075, 0x4f2a, {0xac, 0x8e, 0xd2, 0x59, 0x6a, 0x10, 0x85, 0xcc } \
}
typedef struct _EFI_SMM_ICHN_DISPATCH_PROTOCOL EFI_SMM_ICHN_DISPATCH_PROTOCOL;
//
// Related Definitions
//
//
// ICHN Specific SMIs. These are miscellaneous SMI sources that are supported by the
// ICHN specific SMI implementation. These may change over time. TrapNumber is only
// valid if the Type is Trap.
//
typedef enum {
//
// NOTE: NEVER delete items from this list/enumeration! Doing so will prevent other versions
// of the code from compiling. If the ICH version your driver is written for doesn't support
// some of these SMIs, then simply return EFI_UNSUPPORTED when a child/client tries to register
// for them.
//
IchnMch,
IchnPme,
IchnRtcAlarm,
IchnRingIndicate,
IchnAc97Wake,
IchnSerialIrq,
IchnY2KRollover,
IchnTcoTimeout,
IchnOsTco,
IchnNmi,
IchnIntruderDetect,
IchnBiosWp,
IchnMcSmi,
IchnPmeB0,
IchnThrmSts,
IchnSmBus,
IchnIntelUsb2,
IchnMonSmi7,
IchnMonSmi6,
IchnMonSmi5,
IchnMonSmi4,
IchnDevTrap13,
IchnDevTrap12,
IchnDevTrap11,
IchnDevTrap10,
IchnDevTrap9,
IchnDevTrap8,
IchnDevTrap7,
IchnDevTrap6,
IchnDevTrap5,
IchnDevTrap3,
IchnDevTrap2,
IchnDevTrap1,
IchnDevTrap0,
IchnIoTrap3,
IchnIoTrap2,
IchnIoTrap1,
IchnIoTrap0,
IchnPciExpress,
IchnMonitor,
IchnSpi,
IchnQRT,
IchnGpioUnlock,
//
// INSERT NEW ITEMS JUST BEFORE THIS LINE
//
NUM_ICHN_TYPES // the number of items in this enumeration
} EFI_SMM_ICHN_SMI_TYPE;
typedef struct {
EFI_SMM_ICHN_SMI_TYPE Type;
} EFI_SMM_ICHN_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a ICHN specific SMI handler.
@param DispatchHandle The handle of this dispatch function.
@param DispatchContext The pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
@return None
**/
typedef
VOID
(EFIAPI *EFI_SMM_ICHN_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_ICHN_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver.
@param This The pointer to the EFI_SMM_ICHN_DISPATCH_PROTOCOL instance.
@param DispatchFunction The function to install.
@param DispatchContext The pointer to the dispatch function's context.
The caller fills in this context before calling
the register function to indicate to the register
function the ICHN SMI source for which the dispatch
function should be invoked.
@param DispatchHandle The handle generated by the dispatcher to track the function
instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver could not enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The ICHN input value
is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ICHN_REGISTER)(
IN EFI_SMM_ICHN_DISPATCH_PROTOCOL *This,
IN EFI_SMM_ICHN_DISPATCH DispatchFunction,
IN EFI_SMM_ICHN_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This The pointer to the EFI_SMM_ICHN_DISPATCH_PROTOCOL instance.
@param DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered, and the SMI source has been disabled,
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The handle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ICHN_UNREGISTER)(
IN EFI_SMM_ICHN_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM ICHN specific SMI Dispatch Protocol
//
/**
Provides the parent dispatch service for a given SMI source generator.
**/
struct _EFI_SMM_ICHN_DISPATCH_PROTOCOL {
EFI_SMM_ICHN_REGISTER Register; ///< Installs a child service to be dispatched by this protocol.
EFI_SMM_ICHN_UNREGISTER UnRegister; ///< Removes a child service dispatched by this protocol.
};
extern EFI_GUID gEfiSmmIchnDispatchProtocolGuid;
#endif

176
IntelFrameworkPkg/Include/Protocol/SmmPeriodicTimerDispatch.h Normal file
View File

@ -0,0 +1,176 @@
/** @file
Provides the parent dispatch service for the periodical timer SMI source generator.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_PERIODIC_TIMER_DISPATCH_H_
#define _EFI_SMM_PERIODIC_TIMER_DISPATCH_H_
//
// Global ID for the Periodic Timer SMI Protocol
//
#define EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL_GUID \
{ \
0x9cca03fc, 0x4c9e, 0x4a19, {0x9b, 0x6, 0xed, 0x7b, 0x47, 0x9b, 0xde, 0x55 } \
}
typedef struct _EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL;
//
// Related Definitions
//
typedef struct {
///
/// The minimum period of time that the child gets called, in 100 nanosecond units.
/// The child will be called back after a time greater than the time Period.
///
UINT64 Period;
///
/// The period of time interval between SMIs. Children of this interface
/// should use this field when registering for periodic timer intervals when a finer
/// granularity periodic SMI is desired. Valid values for this field are those returned
/// by GetNextInterval. A value of 0 indicates the parent is allowed to use any SMI
/// interval period to satisfy the requested period.
///
UINT64 SmiTickInterval;
///
/// The actual time in 100 nanosecond units elapsed since last called. A
/// value of 0 indicates an unknown amount of time.
///
UINT64 ElapsedTime;
} EFI_SMM_PERIODIC_TIMER_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Periodic Timer SMI handler.
@param DispatchHandle The handle of this dispatch function.
@param DispatchContext The pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
@return None
**/
typedef
VOID
(EFIAPI *EFI_SMM_PERIODIC_TIMER_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_CONTEXT *DispatchContext
);
/**
Returns the next SMI tick period supported by the chipset. The order
returned is from longest to shortest interval period.
@param This The protocol instance pointer.
@param SmiTickInterval The pointer to pointer of next shorter SMI interval
period supported by the child. This parameter works as a get-first,
get-next field. The first time this function is called, *SmiTickInterval
should be set to NULL to get the longest SMI interval. The returned
*SmiTickInterval should be passed in on subsequent calls to get the
next shorter interval period until *SmiTickInterval = NULL.
@retval EFI_SUCCESS The service returned successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_PERIODIC_TIMER_INTERVAL)(
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
IN OUT UINT64 **SmiTickInterval
);
/**
Register a child SMI source dispatch function with a parent SMM driver
@param This The pointer to the EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
@param DispatchFunction The function to install.
@param DispatchContext The pointer to the dispatch function's context.
Indicates to the register
function the period at which the dispatch function
should be invoked.
@param DispatchHandle The handle generated by the dispatcher to track the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered, and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The period input value
is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_PERIODIC_TIMER_REGISTER)(
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
IN EFI_SMM_PERIODIC_TIMER_DISPATCH DispatchFunction,
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a periodic timer service.
@param This The pointer to the EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL instance.
@param DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered, and the SMI source has been disabled
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The handle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_PERIODIC_TIMER_UNREGISTER)(
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Periodic Timer Dispatch Protocol
//
/**
Provides the parent dispatch service for the periodical timer SMI source generator.
**/
struct _EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL {
///
/// Installs a child service to be dispatched by this protocol.
///
EFI_SMM_PERIODIC_TIMER_REGISTER Register;
///
/// Removes a child service dispatched by this protocol.
///
EFI_SMM_PERIODIC_TIMER_UNREGISTER UnRegister;
///
/// Returns the next SMI tick period that is supported by the chipset.
///
EFI_SMM_PERIODIC_TIMER_INTERVAL GetNextShorterInterval;
};
extern EFI_GUID gEfiSmmPeriodicTimerDispatchProtocolGuid;
#endif

141
IntelFrameworkPkg/Include/Protocol/SmmPowerButtonDispatch.h Normal file
View File

@ -0,0 +1,141 @@
/** @file
Provides the parent dispatch service for the power button SMI source generator.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_POWER_BUTTON_DISPATCH_H_
#define _EFI_SMM_POWER_BUTTON_DISPATCH_H_
//
// Global ID for the Power Button SMI Protocol
//
#define EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL_GUID \
{ \
0xb709efa0, 0x47a6, 0x4b41, {0xb9, 0x31, 0x12, 0xec, 0xe7, 0xa8, 0xee, 0x56 } \
}
typedef struct _EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL;
//
// Related Definitions
//
//
// Power Button. Example, Use for changing LEDs before ACPI OS is on.
// - DXE/BDS Phase
// - OS Install Phase
//
typedef enum {
PowerButtonEntry,
PowerButtonExit
} EFI_POWER_BUTTON_PHASE;
typedef struct {
EFI_POWER_BUTTON_PHASE Phase;
} EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Power Button SMI handler.
@param[in] DispatchHandle The handle of this dispatch function.
@param[in] DispatchContext The pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
**/
typedef
VOID
(EFIAPI *EFI_SMM_POWER_BUTTON_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT *DispatchContext
);
/**
Provides the parent dispatch service for a given SMI source generator
@param[in] This The pointer to the
EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL instance.
@param[in] DispatchFunction The function to install.
@param[in] DispatchContext The pointer to the dispatch function's context.
Indicates to the register
function the Power Button SMI phase for which
to invoke the dispatch function.
@param[out] DispatchHandle Handle generated by the dispatcher to track
the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The Power Button SMI
phase is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_POWER_BUTTON_REGISTER)(
IN EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
IN EFI_SMM_POWER_BUTTON_DISPATCH DispatchFunction,
IN EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a power-button service.
@param[in] This The pointer to the EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL instance.
@param[in] DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered, and the SMI source has been
disabled, if there are no other registered
child dispatch functions for this SMI
source.
@retval EFI_INVALID_PARAMETER The handle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_POWER_BUTTON_UNREGISTER)(
IN EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
/**
@par Protocol Description:
Provides the parent dispatch service for the SMM power button SMI source generator.
**/
struct _EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL {
///
/// Installs a child service to be dispatched by this protocol.
///
EFI_SMM_POWER_BUTTON_REGISTER Register;
///
/// Removes a child service dispatched by this protocol.
///
EFI_SMM_POWER_BUTTON_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmPowerButtonDispatchProtocolGuid;
#endif

143
IntelFrameworkPkg/Include/Protocol/SmmStandbyButtonDispatch.h Normal file
View File

@ -0,0 +1,143 @@
/** @file
Provides the parent dispatch service for the standby button SMI source generator.
The SMM Standby Button Dispatch Protocol is defined in
the Intel Platform Innovation Framework for EFI SMM Core Interface Specification
(SMM CIS) Version 0.9.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_STANDBY_BUTTON_DISPATCH_H_
#define _EFI_SMM_STANDBY_BUTTON_DISPATCH_H_
//
// Share some common definitions with PI SMM
//
#include <Protocol/SmmStandbyButtonDispatch2.h>
//
// Global ID for the Standby Button SMI Protocol
//
#define EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL_GUID \
{ \
0x78965b98, 0xb0bf, 0x449e, {0x8b, 0x22, 0xd2, 0x91, 0x4e, 0x49, 0x8a, 0x98 } \
}
typedef struct _EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL;
//
// Related Definitions
//
typedef struct {
/// Describes whether the child handler should be invoked upon the entry to the button
/// activation or upon exit (i.e., upon receipt of the button press event or upon release of
/// the event).
EFI_STANDBY_BUTTON_PHASE Phase;
} EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Standby Button SMI handler.
@param DispatchHandle The handle of this dispatch function.
@param DispatchContext The pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
**/
typedef
VOID
(EFIAPI *EFI_SMM_STANDBY_BUTTON_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT *DispatchContext
);
/**
Provides the parent dispatch service for a given SMI source generator
@param This The pointer to the EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL instance.
@param DispatchFunction The function to install.
@param DispatchContext The pointer to the dispatch function's context.
Indicates to the register function the Standby
Button SMI phase for which to invoke the dispatch
function.
@param DispatchHandle The handle generated by the dispatcher to track the
function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered, and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver could not enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The Standby Button SMI
phase is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STANDBY_BUTTON_REGISTER)(
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This,
IN EFI_SMM_STANDBY_BUTTON_DISPATCH DispatchFunction,
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver.
@param This The pointer to the EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL instance.
@param DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered, and the SMI source has been disabled,
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The handle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STANDBY_BUTTON_UNREGISTER)(
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Standby Button SMI Dispatch Protocol
//
/**
This protocol provices the parent dispatch service for the standby button SMI source generator.
Provides the ability to install child handlers for the given event types.
**/
struct _EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL {
///
/// Installs a child service to be dispatched by this protocol.
///
EFI_SMM_STANDBY_BUTTON_REGISTER Register;\
///
/// Removes a child service dispatched by this protocol.
///
EFI_SMM_STANDBY_BUTTON_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmStandbyButtonDispatchProtocolGuid;
#endif

151
IntelFrameworkPkg/Include/Protocol/SmmSwDispatch.h Normal file
View File

@ -0,0 +1,151 @@
/** @file
Provides the parent dispatch service for a given SMI source generator.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework for EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_SW_DISPATCH_H_
#define _EFI_SMM_SW_DISPATCH_H_
//
// Global ID for the SW SMI Protocol
//
#define EFI_SMM_SW_DISPATCH_PROTOCOL_GUID \
{ \
0xe541b773, 0xdd11, 0x420c, {0xb0, 0x26, 0xdf, 0x99, 0x36, 0x53, 0xf8, 0xbf } \
}
typedef struct _EFI_SMM_SW_DISPATCH_PROTOCOL EFI_SMM_SW_DISPATCH_PROTOCOL;
//
// Related Definitions
//
//
// A particular chipset may not support all possible software SMI input values.
// For example, the ICH supports only values 00h to 0FFh. The parent only allows a single
// child registration for each SwSmiInputValue.
//
typedef struct {
UINTN SwSmiInputValue;
} EFI_SMM_SW_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Software SMI handler.
@param DispatchHandle The handle of this dispatch function.
@param DispatchContext The pointer to the dispatch function's context.
The SwSmiInputValue field is filled in
by the software dispatch driver prior to
invoking this dispatch function.
The dispatch function will only be called
for input values for which it is registered.
@return None
**/
typedef
VOID
(EFIAPI *EFI_SMM_SW_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_SW_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver.
@param This The pointer to the EFI_SMM_SW_DISPATCH_PROTOCOL instance.
@param DispatchFunction The function to install.
@param DispatchContext The pointer to the dispatch function's context.
Indicates to the register
function the Software SMI input value for which
to invoke the dispatch function.
@param DispatchHandle The handle generated by the dispatcher to track
the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The SW driver could not enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The SW SMI input value
is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SW_REGISTER)(
IN EFI_SMM_SW_DISPATCH_PROTOCOL *This,
IN EFI_SMM_SW_DISPATCH DispatchFunction,
IN EFI_SMM_SW_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This The pointer to the EFI_SMM_SW_DISPATCH_PROTOCOL instance.
@param DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered and the SMI source has been disabled
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The handle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SW_UNREGISTER)(
IN EFI_SMM_SW_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Software SMI Dispatch Protocol
//
/**
Provides the parent dispatch service for a given SMI source generator.
**/
///
/// Inconsistent with the specification here:
/// In The Framework specification SmmCis, this definition is named as
/// _EFI_SMM_ICHN_DISPATCH_PROTOCOL by mistake.
///
struct _EFI_SMM_SW_DISPATCH_PROTOCOL {
///
/// Installs a child service to be dispatched by this protocol.
///
EFI_SMM_SW_REGISTER Register;
///
/// Removes a child service dispatched by this protocol.
///
EFI_SMM_SW_UNREGISTER UnRegister;
///
/// A read-only field that describes the maximum value that can be used
/// in the EFI_SMM_SW_DISPATCH_PROTOCOL.Register() service.
///
UINTN MaximumSwiValue;
};
extern EFI_GUID gEfiSmmSwDispatchProtocolGuid;
#endif

135
IntelFrameworkPkg/Include/Protocol/SmmSxDispatch.h Normal file
View File

@ -0,0 +1,135 @@
/** @file
Provides the parent dispatch service for a given Sx-state source generator.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_SX_DISPATCH_H_
#define _EFI_SMM_SX_DISPATCH_H_
//
// Share some common definitions with PI SMM
//
#include <Protocol/SmmSxDispatch2.h>
//
// Global ID for the Sx SMI Protocol
//
#define EFI_SMM_SX_DISPATCH_PROTOCOL_GUID \
{ \
0x14fc52be, 0x1dc, 0x426c, {0x91, 0xae, 0xa2, 0x3c, 0x3e, 0x22, 0xa, 0xe8 } \
}
typedef struct _EFI_SMM_SX_DISPATCH_PROTOCOL EFI_SMM_SX_DISPATCH_PROTOCOL;
typedef struct {
EFI_SLEEP_TYPE Type;
EFI_SLEEP_PHASE Phase;
} EFI_SMM_SX_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Sx state SMI handler.
@param DispatchHandle The handle of this dispatch function.
@param DispatchContext The pointer to the dispatch function's context.
The Type and Phase fields are filled in by the Sx dispatch driver
prior to invoking this dispatch function. For this interface,
the Sx driver will call the dispatch function for all Sx type
and phases, so the Sx state handler(s) must check the Type and
Phase field of EFI_SMM_SX_DISPATCH_CONTEXT, and act accordingly.
@return None
**/
typedef
VOID
(EFIAPI *EFI_SMM_SX_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_SX_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver.
@param This The pointer to the EFI_SMM_SX_DISPATCH_PROTOCOL instance.
@param DispatchFunction The function to install.
@param DispatchContext The pointer to the dispatch function's context.
The caller fills in this context before calling
the register function to indicates to the register
function which Sx state type and phase the caller
wishes to be called back on. For this interface,
the Sx driver will call the registered handlers for
all Sx type and phases, so the Sx state handler(s)
must check the Type and Phase field of the Dispatch
context, and act accordingly.
@param DispatchHandle The handle of dispatch function, for interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_UNSUPPORTED The Sx driver or hardware does not support that
Sx Type/Phase.
@retval EFI_DEVICE_ERROR The Sx driver was unable to enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. Type & Phase are not
within a valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SX_REGISTER)(
IN EFI_SMM_SX_DISPATCH_PROTOCOL *This,
IN EFI_SMM_SX_DISPATCH DispatchFunction,
IN EFI_SMM_SX_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters an Sx-state service
@param This The pointer to the EFI_SMM_SX_DISPATCH_PROTOCOL instance.
@param DispatchHandle The handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully unregistered, and the
SMI source has been disabled, if there are no other registered child
dispatch functions for this SMI source.
@retval EFI_INVALID_PARAMETER Handle is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SX_UNREGISTER)(
IN EFI_SMM_SX_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Child Dispatch Protocol
//
/**
Provides the parent dispatch service for a given Sx-state source generator.
**/
struct _EFI_SMM_SX_DISPATCH_PROTOCOL {
EFI_SMM_SX_REGISTER Register; ///< Installs a child service to be dispatched by this protocol.
EFI_SMM_SX_UNREGISTER UnRegister; ///< Removes a child service dispatched by this protocol.
};
extern EFI_GUID gEfiSmmSxDispatchProtocolGuid;
#endif

136
IntelFrameworkPkg/Include/Protocol/SmmUsbDispatch.h Normal file
View File

@ -0,0 +1,136 @@
/** @file
Provides the parent dispatch service for the USB SMI source generator.
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_USB_DISPATCH_H_
#define _EFI_SMM_USB_DISPATCH_H_
//
// Share some common definitions with PI SMM
//
#include <Protocol/SmmUsbDispatch2.h>
//
// Global ID for the USB Protocol
//
#define EFI_SMM_USB_DISPATCH_PROTOCOL_GUID \
{ \
0xa05b6ffd, 0x87af, 0x4e42, {0x95, 0xc9, 0x62, 0x28, 0xb6, 0x3c, 0xf3, 0xf3 } \
}
typedef struct _EFI_SMM_USB_DISPATCH_PROTOCOL EFI_SMM_USB_DISPATCH_PROTOCOL;
typedef struct {
///
/// Describes whether this child handler will be invoked in response to a USB legacy
/// emulation event, such as port-trap on the PS/2* keyboard control registers, or to a
/// USB wake event, such as resumption from a sleep state.
///
EFI_USB_SMI_TYPE Type;
///
/// The device path is part of the context structure and describes the location of the
/// particular USB host controller in the system for which this register event will occur.
/// This location is important because of the possible integration of several USB host
/// controllers in a system.
///
EFI_DEVICE_PATH_PROTOCOL *Device;
} EFI_SMM_USB_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a USB SMI handler.
@param[in] DispatchHandle Handle of this dispatch function.
@param[in] DispatchContext Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
**/
typedef
VOID
(EFIAPI *EFI_SMM_USB_DISPATCH)(
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_USB_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver.
@param[in] This The pointer to the EFI_SMM_USB_DISPATCH_PROTOCOL instance.
@param[in] DispatchFunction The pointer to dispatch function to be invoked
for this SMI source.
@param[in] DispatchContext The pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function the USB SMI types for which the dispatch
function should be invoked.
@param[out] DispatchHandle The handle generated by the dispatcher to track the
function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_OUT_OF_RESOURCES Not enough memory (system or SMM) to manage this
child.
@retval EFI_INVALID_PARAMETER DispatchContext is invalid. The USB SMI type
is not within valid range.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_USB_REGISTER)(
IN EFI_SMM_USB_DISPATCH_PROTOCOL *This,
IN EFI_SMM_USB_DISPATCH DispatchFunction,
IN EFI_SMM_USB_DISPATCH_CONTEXT *DispatchContext,
OUT EFI_HANDLE *DispatchHandle
);
/**
Unregisters a USB service.
@param[in] This The pointer to the EFI_SMM_USB_DISPATCH_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered and the SMI source has been disabled
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_USB_UNREGISTER)(
IN EFI_SMM_USB_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
///
/// The EFI_SMM_USB_DISPATCH_PROTOCOL provides the ability to install child handlers for the
/// given event types.
///
struct _EFI_SMM_USB_DISPATCH_PROTOCOL {
EFI_SMM_USB_REGISTER Register;
EFI_SMM_USB_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmUsbDispatchProtocolGuid;
#endif

6
edksetup.bat
View File

@ -118,9 +118,9 @@ goto check_cygwin
if not defined NASM_PREFIX (
@echo.
@echo !!! WARNING !!! NASM_PREFIX environment variable is not set
@if exist "C:\nasm\nasm.exe" @set "NASM_PREFIX=C:\nasm\"
@if exist "C:\nasm\nasm.exe" @echo Found nasm.exe, setting the environment variable to C:\nasm\
@if not exist "C:\nasm\nasm.exe" echo Attempting to build modules that require NASM will fail.
@if exist "C:\Program Files (x86)\NASM\nasm.exe" @set "NASM_PREFIX=C:\Program Files (x86)\NASM\"
@if exist "C:\Program Files (x86)\NASM\nasm.exe" @echo Found nasm.exe, setting the environment variable to C:\Program Files (x86)\NASM
@if not exist "C:\Program Files (x86)\NASM\nasm.exe" echo Attempting to build modules that require NASM will fail.
)
:check_cygwin