sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial directory structure of IntelFrameworkPkg.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2657 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
bxing
2007-06-15 10:02:42 +00:00
parent 5879b8754a
commit 79964ac84e
67 changed files with 17948 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,161 @@
/** @file
Definition of the ACPI Support protocol.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: AcpiSupport.h
@par Revision Reference:
This is defined in the ACPI Specification 0.9.
**/
#ifndef _ACPI_SUPPORT_PROTOCOL_H_
#define _ACPI_SUPPORT_PROTOCOL_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 Data Definitions
//
//
// ACPI Version bitmap definition:
//
// EFI_ACPI_TABLE_VERSION_1_0B - ACPI Version 1.0b
// EFI_ACPI_TABLE_VERSION_2_0 - ACPI Version 2.0
// EFI_ACPI_TABLE_VERSION_3_0 - ACPI Version 3.0
// EFI_ACPI_TABLE_VERSION_NONE - No ACPI Versions. This might be used
// to create memory-based operation regions or other information
// that is not part of the ACPI "tree" but must still be found
// in ACPI memory space and/or managed by the core ACPI driver.
//
// Note that EFI provides discrete GUIDs for each version of ACPI
// that is supported. It is expected that each EFI GUIDed
// version of ACPI will also have a corresponding bitmap
// definition. This allows maintenance of separate ACPI trees
// for each distinctly different version of ACPI.
//
#define EFI_ACPI_TABLE_VERSION UINT32
#define EFI_ACPI_TABLE_VERSION_NONE (1 << 0)
#define EFI_ACPI_TABLE_VERSION_1_0B (1 << 1)
#define EFI_ACPI_TABLE_VERSION_2_0 (1 << 2)
#define EFI_ACPI_TABLE_VERSION_3_0 (1 << 3)
//
// 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 Pointer for returning the table buffer.
@param Version Updated with the ACPI versions to which this table belongs.
@param Handle 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 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 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.
@param This A pointer to the EFI_ACPI_SUPPORT_PROTOCOL instance.
@param Version Indicates to which version(s) of ACPI that 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
//
/**
@par Protocol Description:
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.
@param GetAcpiTable
Returns a table specified by an index if it exists.
@param SetAcpiTable
Adds, removes, or updates ACPI tables
@param PublishTables
Publishes the ACPI tables.
**/
struct _EFI_ACPI_SUPPORT_PROTOCOL {
EFI_ACPI_GET_ACPI_TABLE GetAcpiTable;
EFI_ACPI_SET_ACPI_TABLE SetAcpiTable;
EFI_ACPI_PUBLISH_TABLES PublishTables;
};
//
// Extern the GUID for protocol users.
//
extern EFI_GUID gEfiAcpiSupportProtocolGuid;
#endif

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

@@ -0,0 +1,102 @@
/** @file
Definition of the Boot Script Save protocol.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: BootScriptSave.h
@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;
//
// Protocol Member_Function
//
/**
Adds a record into a specified Framework boot script table.
@param This A pointer to the EFI_BOOT_SCRIPT_SAVE_PROTOCOL instance.
@param TableName 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 ... 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 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
);
//
// S3 Save Protocol data structure
//
/**
@par Protocol Description:
The EFI_BOOT_SCRIPT_SAVE_PROTOCOL publishes the Framework boot script abstractions
to store or record various boot scripts into boot script tables.
@param Write
Writes various boot scripts to a boot script table.
@param CloseTable
Retrieves and closes a script table.
**/
struct _EFI_BOOT_SCRIPT_SAVE_PROTOCOL {
EFI_BOOT_SCRIPT_WRITE Write;
EFI_BOOT_SCRIPT_CLOSE_TABLE CloseTable;
};
extern EFI_GUID gEfiBootScriptSaveProtocolGuid;
#endif

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

@@ -0,0 +1,125 @@
/** @file
This code abstracts the CPU IO Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: CpuIO.h
@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_
#define EFI_CPU_IO_PROTOCOL_GUID \
{ \
0xB0732526, 0x38C8, 0x4b40, {0x88, 0x77, 0x61, 0xC7, 0xB0, 0x6A, 0xAC, 0x45 } \
}
typedef struct _EFI_CPU_IO_PROTOCOL EFI_CPU_IO_PROTOCOL;
//
// *******************************************************
// EFI_CPU_IO_PROTOCOL_WIDTH
// *******************************************************
//
typedef enum {
EfiCpuIoWidthUint8,
EfiCpuIoWidthUint16,
EfiCpuIoWidthUint32,
EfiCpuIoWidthUint64,
EfiCpuIoWidthFifoUint8,
EfiCpuIoWidthFifoUint16,
EfiCpuIoWidthFifoUint32,
EfiCpuIoWidthFifoUint64,
EfiCpuIoWidthFillUint8,
EfiCpuIoWidthFillUint16,
EfiCpuIoWidthFillUint32,
EfiCpuIoWidthFillUint64,
EfiCpuIoWidthMaximum
} EFI_CPU_IO_PROTOCOL_WIDTH;
//
// *******************************************************
// EFI_CPU_IO_PROTOCOL_IO_MEM
// *******************************************************
//
/**
Enables a driver to access memory-mapped registers in the EFI system memory space.
Or, Enables a driver to access registers in the EFI CPU I/O space.
@param This A pointer to the EFI_CPU_IO_PROTOCOL instance.
@param Width Signifies the width of the I/O or Memory operation.
@param Address The base address of the I/O or Memoryoperation.
@param Count The number of I/O or Memory operations to perform.
The number of bytes moved is Width size * Count, starting at Address.
@param 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 EFI system.
@retval EFI_INVALID_PARAMETER Width is invalid for this EFI system.Or Buffer is NULL.
@retval EFI_UNSUPPORTED The Buffer is not aligned for the given Width.
Or,The address range specified by Address, Width, and Count is not valid for this EFI system.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_CPU_IO_PROTOCOL_IO_MEM) (
IN EFI_CPU_IO_PROTOCOL *This,
IN EFI_CPU_IO_PROTOCOL_WIDTH Width,
IN UINT64 Address,
IN UINTN Count,
IN OUT VOID *Buffer
);
//
// *******************************************************
// EFI_CPU_IO_PROTOCOL_ACCESS
// *******************************************************
//
typedef struct {
EFI_CPU_IO_PROTOCOL_IO_MEM Read;
EFI_CPU_IO_PROTOCOL_IO_MEM Write;
} EFI_CPU_IO_PROTOCOL_ACCESS;
//
// *******************************************************
// EFI_CPU_IO_PROTOCOL
// *******************************************************
//
/**
@par Protocol Description:
Provides the basic memory and I/O interfaces that are used to abstract
accesses to devices in a system.
@param Mem.Read
Allows reads from memory-mapped I/O space.
@param Mem.Write
Allows writes to memory-mapped I/O space.
@param Io.Read
Allows reads from I/O space.
@param Io.Write
Allows writes to I/O space.
**/
struct _EFI_CPU_IO_PROTOCOL {
EFI_CPU_IO_PROTOCOL_ACCESS Mem;
EFI_CPU_IO_PROTOCOL_ACCESS Io;
};
extern EFI_GUID gEfiCpuIoProtocolGuid;
#endif

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

@@ -0,0 +1,212 @@
/** @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.
For more information please look at Intel Platform Innovation
Framework for EFI Data Hub Specification.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: DataHub.h
@par Revision Reference:
This 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 must
// change and the HeaderSize will change if the definition of
// EFI_DATA_RECORD_HEADER is extended.
//
// 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 DateHub.doc 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 description
@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.
@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.
**/
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.
**/
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.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_DATA_HUB_UNREGISTER_FILTER_DRIVER) (
IN EFI_DATA_HUB_PROTOCOL *This,
IN EFI_EVENT FilterEvent
);
/**
@par Protocol Description:
This protocol is used to log information and register filter drivers
to receive data records.
@param LogData
Logs a data record.
@param GetNextDataRecord
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.
@param RegisterFilterDriver
Allows the registration of an EFI event to act as a filter driver for all data records that are logged.
@param UnregisterFilterDriver
Used to remove a filter driver that was added with RegisterFilterDriver().
**/
struct _EFI_DATA_HUB_PROTOCOL {
EFI_DATA_HUB_LOG_DATA LogData;
EFI_DATA_HUB_GET_NEXT_RECORD GetNextRecord;
EFI_DATA_HUB_REGISTER_FILTER_DRIVER RegisterFilterDriver;
EFI_DATA_HUB_UNREGISTER_FILTER_DRIVER UnregisterFilterDriver;
};
extern EFI_GUID gEfiDataHubProtocolGuid;
#endif

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

@@ -0,0 +1,319 @@
/** @file
This file declares Firmware Volume protocol.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: FirmwareVolume.h
@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 EFI_SIGNATURE_32 ('_', 'F', 'V', '_')
typedef struct _EFI_FIRMWARE_VOLUME_PROTOCOL EFI_FIRMWARE_VOLUME_PROTOCOL;
//
// EFI_FV_ATTRIBUTES bit definitions
//
typedef UINT64 EFI_FV_ATTRIBUTES;
//
// ************************************************************
// 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, returns
resulting attributes in output parameter
@param This Calling context
@param Attributes output buffer which contains attributes
@retval EFI_INVALID_PARAMETER
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FV_GET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
OUT EFI_FV_ATTRIBUTES *Attributes
);
/**
Sets volume attributes
@param This Calling context
@param Attributes Buffer which contains attributes
@retval EFI_INVALID_PARAMETER
@retval EFI_DEVICE_ERROR
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FV_SET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN OUT EFI_FV_ATTRIBUTES *Attributes
);
typedef UINT32 EFI_FV_FILE_ATTRIBUTES;
#define EFI_FV_FILE_ATTRIB_ALIGNMENT 0x0000001F
/**
Read the requested file (NameGuid) and returns data in Buffer.
@param This Calling context
@param NameGuid Filename identifying which file to read
@param Buffer 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 Indicates the buffer size passed in, and on output the size
required to complete the read
@param FoundType Indicates the type of the file who's data is returned
@param FileAttributes Indicates the attributes of the file who's data is resturned
@param AuthenticationStatus Indicates the authentication status of the data
@retval EFI_SUCCESS
@retval EFI_WARN_BUFFER_TOO_SMALL
@retval EFI_NOT_FOUND
@retval EFI_DEVICE_ERROR
@retval EFI_ACCESS_DENIED
**/
typedef
EFI_STATUS
(EFIAPI *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 Calling context
@param NameGuid Filename identifying the file from which to read
@param SectionType Indicates what section type to retrieve
@param SectionInstance Indicates which instance of SectionType to retrieve
@param Buffer 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 Indicates the buffer size passed in, and on output the size
required to complete the read
@param AuthenticationStatus Indicates the authentication status of the data
@retval EFI_SUCCESS
@retval EFI_WARN_BUFFER_TOO_SMALL
@retval EFI_OUT_OF_RESOURCES
@retval EFI_NOT_FOUND
@retval EFI_DEVICE_ERROR
@retval EFI_ACCESS_DENIED
**/
typedef
EFI_STATUS
(EFIAPI *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 EFI_FV_WRITE_POLICY;
#define EFI_FV_UNRELIABLE_WRITE 0x00000000
#define EFI_FV_RELIABLE_WRITE 0x00000001
typedef struct {
EFI_GUID *NameGuid;
EFI_FV_FILETYPE Type;
EFI_FV_FILE_ATTRIBUTES FileAttributes;
VOID *Buffer;
UINT32 BufferSize;
} EFI_FV_WRITE_FILE_DATA;
/**
Write the supplied file (NameGuid) to the FV.
@param This Calling context
@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
@retval EFI_OUT_OF_RESOURCES
@retval EFI_DEVICE_ERROR
@retval EFI_WRITE_PROTECTED
@retval EFI_NOT_FOUND
@retval EFI_INVALID_PARAMETER
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FV_WRITE_FILE) (
IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,
IN UINT32 NumberOfFiles,
IN EFI_FV_WRITE_POLICY WritePolicy,
IN EFI_FV_WRITE_FILE_DATA *FileData
);
/**
Given the input key, search for the next matching file in the volume.
@param This Calling context
@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 Indicates the file type to filter for
@param NameGuid Guid filename of the file found
@param Attributes Attributes of the file found
@param Size Size in bytes of the file found
@retval EFI_SUCCESS
@retval EFI_NOT_FOUND
@retval EFI_DEVICE_ERROR
@retval EFI_ACCESS_DENIED
**/
typedef
EFI_STATUS
(EFIAPI *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
);
/**
@par Protocol Description:
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.
@param GetVolumeAttributes
Retrieves volume capabilities and current settings.
@param SetVolumeAttributes
Modifies the current settings of the firmware volume.
@param ReadFile
Reads an entire file from the firmware volume.
@param ReadSection
Reads a single section from a file into a buffer.
@param WriteFile
Writes an entire file into the firmware volume.
@param GetNextFile
Provides service to allow searching the firmware volume.
@param KeySize
Data field that indicates the size in bytes of the Key input buffer for
the GetNextFile() API.
@param ParentHandle
Handle of the parent firmware volume.
**/
struct _EFI_FIRMWARE_VOLUME_PROTOCOL {
EFI_FV_GET_ATTRIBUTES GetVolumeAttributes;
EFI_FV_SET_ATTRIBUTES SetVolumeAttributes;
EFI_FV_READ_FILE ReadFile;
EFI_FV_READ_SECTION ReadSection;
EFI_FV_WRITE_FILE WriteFile;
EFI_FV_GET_NEXT_FILE GetNextFile;
UINT32 KeySize;
EFI_HANDLE ParentHandle;
};
extern EFI_GUID gEfiFirmwareVolumeProtocolGuid;
#endif

251
IntelFrameworkPkg/Include/Protocol/FirmwareVolumeBlock.h Normal file
View File

@@ -0,0 +1,251 @@
/** @file
This file declares Firmware Volume Block protocol.
Low level firmware device access routines to abstract firmware device
hardware.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: FirmwareVolumeBlock.h
@par Revision Reference:
This protocol is defined in Framework of EFI Firmware Volume Block specification.
Version 0.9
**/
#ifndef _FIRMWARE_VOLUME_BLOCK_H_
#define _FIRMWARE_VOLUME_BLOCK_H_
#define EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID \
{ \
0xDE28BC59, 0x6228, 0x41BD, {0xBD, 0xF6, 0xA3, 0xB9, 0xAD, 0xB5, 0x8D, 0xA1 } \
}
typedef struct _EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL;
/**
Retrieves Volume attributes. No polarity translations are done.
@param This Calling context
@param Attributes output buffer which contains attributes
@retval EFI_INVALID_PARAMETER
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_GET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_FVB_ATTRIBUTES *Attributes
)
;
/**
Sets Volume attributes. No polarity translations are done.
@param This Calling context
@param Attributes On input: contains new attributes
On output: contains current attributes of FV
@retval EFI_INVALID_PARAMETER
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_SET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN OUT EFI_FVB_ATTRIBUTES *Attributes
)
;
/**
Retrieves the physical address of a memory mapped FV.
@param This Calling context
@param Attributes Address is a pointer to a caller allocated EFI_PHYSICAL_ADDRESS
that on successful return from GetPhysicalAddress() contains the
base address of the firmware volume.
@retval EFI_UNSUPPORTED
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_GET_PHYSICAL_ADDRESS) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_PHYSICAL_ADDRESS *Address
)
;
/**
Retrieves the size in bytes of a specific block within an FV.
@param This Calling context.
@param Lba Indicates which block to return the size for.
@param BlockSize BlockSize is a pointer to a caller allocated
UINTN in which the size of the block is returned.
@param NumberOfBlocks NumberOfBlocks is a 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_INVALID_PARAMETER
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_GET_BLOCK_SIZE) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
OUT UINTN *BlockSize,
OUT UINTN *NumberOfBlocks
)
;
/**
Reads data beginning at Lba:Offset from FV and places the data in Buffer.
The read terminates either when *NumBytes of data have been read, or when
a block boundary is reached. *NumBytes is updated to reflect the actual
number of bytes read.
@param This Calling context
@param Lba Block in which to begin read
@param Offset Offset in the block at which to begin read
@param NumBytes At input, indicates the requested read size. At output, indicates
the actual number of bytes read.
@param Buffer Data buffer in which to place data read.
@retval EFI_INVALID_PARAMETER
@retval EFI_NOT_FOUND
@retval EFI_DEVICE_ERROR
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_READ) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
OUT UINT8 *Buffer
)
;
/**
Writes data beginning at Lba:Offset from FV. The write terminates either
when *NumBytes of data have been written, or when a block boundary is
reached. *NumBytes is updated to reflect the actual number of bytes
written.
@param This Calling context
@param Lba Block in which to begin write
@param Offset Offset in the block at which to begin write
@param NumBytes At input, indicates the requested write size. At output, indicates
the actual number of bytes written.
@param Buffer Buffer containing source data for the write.
@retval EFI_INVALID_PARAMETER
@retval EFI_NOT_FOUND
@retval EFI_DEVICE_ERROR
@retval EFI_SUCCESS
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_WRITE) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
)
;
#define EFI_LBA_LIST_TERMINATOR 0xFFFFFFFFFFFFFFFFULL
/**
The EraseBlock() function erases one or more blocks as denoted by the
variable argument list. The entire parameter list of blocks must be verified
prior to 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 EraseBlock() function must return
EFI_INVALID_PARAMETER without modifying the contents of the firmware volume.
@param This Calling context
@param ... Starting LBA followed by Number of Lba to erase. a -1 to terminate
the list.
@retval EFI_INVALID_PARAMETER
@retval EFI_DEVICE_ERROR
@retval EFI_SUCCESS
@retval EFI_ACCESS_DENIED
**/
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_ERASE_BLOCKS) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
...
)
;
/**
@par Protocol Description:
This protocol provides control over block-oriented firmware devices.
Typically, the FFS (or an alternate file system) driver consumes the
Firmware Volume Block Protocol and produces the Firmware Volume Protocol.
@param GetAttributes
Retrieves the current volume attributes.
@param SetAttributes
Sets the current volume attributes.
@param GetPhysicalAddress
Retrieves the memory-mapped address of the firmware volume.
@param GetBlockSize
Retrieves the size for a specific block.
@param Read
Reads n bytes into a buffer from the firmware volume hardware.
@param Write
Writes n bytes from a buffer into the firmware volume hardware.
@param EraseBlocks
Erases specified block(s) and sets all values as indicated by
the EFI_FVB_ERASE_POLARITY bit.
@param ParentHandle
Handle of the parent firmware volume.
**/
struct _EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL {
EFI_FVB_GET_ATTRIBUTES GetVolumeAttributes;
EFI_FVB_SET_ATTRIBUTES SetVolumeAttributes;
EFI_FVB_GET_PHYSICAL_ADDRESS GetPhysicalAddress;
EFI_FVB_GET_BLOCK_SIZE GetBlockSize;
EFI_FVB_READ Read;
EFI_FVB_WRITE Write;
EFI_FVB_ERASE_BLOCKS EraseBlocks;
EFI_HANDLE ParentHandle;
};
extern EFI_GUID gEfiFirmwareVolumeBlockProtocolGuid;
#endif

942
IntelFrameworkPkg/Include/Protocol/Hii.h Normal file
View File

@@ -0,0 +1,942 @@
/** @file
This file defines the Human Interface Infrastructure protocol which will
be used by resources which want to publish IFR/Font/String data and have it
collected by the Configuration engine.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: Hii.h
@par Revision Reference:
This protocol is defined in HII spec 0.92.
**/
#ifndef _HII_H_
#define _HII_H_
#define EFI_HII_PROTOCOL_GUID \
{ \
0xd7ad636e, 0xb997, 0x459b, {0xbf, 0x3f, 0x88, 0x46, 0x89, 0x79, 0x80, 0xe1} \
}
// BugBug:
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// If UGA goes away we need to put this some place. I'm not sure where?
//
//typedef struct {
// UINT8 Blue;
// UINT8 Green;
// UINT8 Red;
// UINT8 Reserved;
//} EFI_UGA_PIXEL;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
typedef struct _EFI_HII_PROTOCOL EFI_HII_PROTOCOL;
//
// Global definition
//
#define NARROW_CHAR 0xFFF0
#define WIDE_CHAR 0xFFF1
#define NON_BREAKING_CHAR 0xFFF2
#define GLYPH_WIDTH 8
#define GLYPH_HEIGHT 19
#define EFI_HII_FONT 1
#define EFI_HII_STRING 2
#define EFI_HII_IFR 3
#define EFI_HII_KEYBOARD 4
#define EFI_HII_HANDLES 5
#define EFI_HII_VARIABLE 6
#define EFI_HII_DEVICE_PATH 7
// References to string tokens must use this macro to enable scanning for
// token usages.
//
#define STRING_TOKEN(t) t
//
// The following types are currently defined:
//
typedef UINT16 EFI_FORM_ID;
typedef UINT16 EFI_FORM_LABEL;
#pragma pack(1)
typedef struct {
UINT32 Length;
UINT16 Type;
} EFI_HII_PACK_HEADER;
//
// A form list consists of a large variety of structure
// possibilities so to represent the binary blob of data
// associated with a package of forms, we will assume a
// pointer to a self-describing data buffer.
//
typedef struct {
EFI_HII_PACK_HEADER Header;
} EFI_HII_IFR_PACK;
typedef struct {
EFI_HII_PACK_HEADER Header; // Must be filled in
EFI_HANDLE ImageHandle; // Must be filled in
EFI_HANDLE DeviceHandle; // Optional
EFI_HANDLE ControllerHandle; // Optional
EFI_HANDLE CallbackHandle; // Optional
EFI_HANDLE COBExportHandle; // Optional
} EFI_HII_HANDLE_PACK;
//
// ********************************************************
// EFI_VARIABLE_CONTENTS
// ********************************************************
//
typedef struct {
EFI_HII_PACK_HEADER Header;
EFI_GUID VariableGuid;
UINT32 VariableNameLength;
UINT16 VariableId;
//
// CHAR16 VariableName[]; //Null-terminated
//
} EFI_HII_VARIABLE_PACK;
//
// ********************************************************
// EFI_DEVICE_PATH_PACK
// ********************************************************
//
typedef struct {
EFI_HII_PACK_HEADER Header;
//
// EFI_DEVICE_PATH DevicePath[];
//
} EFI_HII_DEVICE_PATH_PACK;
//
// ********************************************************
// EFI_HII_DATA_TABLE
// ********************************************************
//
typedef struct {
EFI_HII_HANDLE HiiHandle;
EFI_GUID PackageGuid;
UINT32 DataTableSize;
UINT32 IfrDataOffset;
UINT32 StringDataOffset;
UINT32 VariableDataOffset;
UINT32 DevicePathOffset;
UINT32 NumberOfVariableData;
UINT32 NumberOfLanguages;
//
// EFI_HII_DEVICE_PATH_PACK DevicePath[];
// EFI_HII_VARIABLE_PACK VariableData[];
// EFI_HII_IFR_PACK IfrData;
// EFI_HII_STRING_PACK StringData[];
//
} EFI_HII_DATA_TABLE;
//
// ********************************************************
// EFI_HII_EXPORT_TABLE
// ********************************************************
//
typedef struct {
UINT32 NumberOfHiiDataTables;
EFI_GUID Revision;
//
// EFI_HII_DATA_TABLE HiiDataTable[];
//
} EFI_HII_EXPORT_TABLE;
typedef struct {
BOOLEAN FormSetUpdate; // If TRUE, next variable is significant
EFI_PHYSICAL_ADDRESS FormCallbackHandle; // If not 0, will update Formset with this info
BOOLEAN FormUpdate; // If TRUE, next variable is significant
UINT16 FormValue; // specify which form is to be updated if FormUpdate value is TRUE.
STRING_REF FormTitle; // If not 0, will update Form with this info
UINT16 DataCount; // The number of Data entries in this structure
UINT8 *Data; // An array of 1+ op-codes, specified by DataCount
} EFI_HII_UPDATE_DATA;
//
// String attributes
//
#define LANG_RIGHT_TO_LEFT 0x00000001
//
// A string package is used to localize strings to a particular
// language. The package is associated with a particular driver
// or set of drivers. Tools are used to associate tokens with
// string references in forms and in programs. These tokens are
// language agnostic. When paired with a language pack (directly
// or indirectly), the string token resolves into an actual
// UNICODE string. The NumStringPointers determines how many
// StringPointers (offset values) there are as well as the total
// number of Strings that are defined.
//
typedef struct {
EFI_HII_PACK_HEADER Header;
RELOFST LanguageNameString;
RELOFST PrintableLanguageName;
UINT32 NumStringPointers;
UINT32 Attributes;
//
// RELOFST StringPointers[];
// EFI_STRING Strings[];
//
} EFI_HII_STRING_PACK;
//
// Glyph Attributes
//
#define EFI_GLYPH_NON_SPACING 1
#define EFI_GLYPH_WIDE 2
typedef struct {
CHAR16 UnicodeWeight;
UINT8 Attributes;
UINT8 GlyphCol1[GLYPH_HEIGHT];
} EFI_NARROW_GLYPH;
typedef struct {
CHAR16 UnicodeWeight;
UINT8 Attributes;
UINT8 GlyphCol1[GLYPH_HEIGHT];
UINT8 GlyphCol2[GLYPH_HEIGHT];
UINT8 Pad[3];
} EFI_WIDE_GLYPH;
//
// A font list consists of a font header followed by a series
// of glyph structures. Note that fonts are not language specific.
//
typedef struct {
EFI_HII_PACK_HEADER Header;
UINT16 NumberOfNarrowGlyphs;
UINT16 NumberOfWideGlyphs;
} EFI_HII_FONT_PACK;
//
// The IfrData in the EFI_HII_IFR_PACK structure definition
// is variable length, and not really part of the header. To
// simplify from code the size of the header, define an
// identical structure that does not include the IfrData field.
// Then use sizeof() this new structure to determine the
// actual size of the header.
//
typedef struct {
EFI_HII_PACK_HEADER Header;
} EFI_HII_IFR_PACK_HEADER;
//
// pedef EFI_HII_PACK_HEADER EFI_HII_IFR_PACK_HEADER;
//
typedef enum {
EfiKeyLCtrl,
EfiKeyA0,
EfiKeyLAlt,
EfiKeySpaceBar,
EfiKeyA2,
EfiKeyA3,
EfiKeyA4,
EfiKeyRCtrl,
EfiKeyLeftArrow,
EfiKeyDownArrow,
EfiKeyRightArrow,
EfiKeyZero,
EfiKeyPeriod,
EfiKeyEnter,
EfiKeyLShift,
EfiKeyB0,
EfiKeyB1,
EfiKeyB2,
EfiKeyB3,
EfiKeyB4,
EfiKeyB5,
EfiKeyB6,
EfiKeyB7,
EfiKeyB8,
EfiKeyB9,
EfiKeyB10,
EfiKeyRshift,
EfiKeyUpArrow,
EfiKeyOne,
EfiKeyTwo,
EfiKeyThree,
EfiKeyCapsLock,
EfiKeyC1,
EfiKeyC2,
EfiKeyC3,
EfiKeyC4,
EfiKeyC5,
EfiKeyC6,
EfiKeyC7,
EfiKeyC8,
EfiKeyC9,
EfiKeyC10,
EfiKeyC11,
EfiKeyC12,
EfiKeyFour,
EfiKeyFive,
EfiKeySix,
EfiKeyPlus,
EfiKeyTab,
EfiKeyD1,
EfiKeyD2,
EfiKeyD3,
EfiKeyD4,
EfiKeyD5,
EfiKeyD6,
EfiKeyD7,
EfiKeyD8,
EfiKeyD9,
EfiKeyD10,
EfiKeyD11,
EfiKeyD12,
EfiKeyD13,
EfiKeyDel,
EfiKeyEnd,
EfiKeyPgDn,
EfiKeySeven,
EfiKeyEight,
EfiKeyNine,
EfiKeyE0,
EfiKeyE1,
EfiKeyE2,
EfiKeyE3,
EfiKeyE4,
EfiKeyE5,
EfiKeyE6,
EfiKeyE7,
EfiKeyE8,
EfiKeyE9,
EfiKeyE10,
EfiKeyE11,
EfiKeyE12,
EfiKeyBackSpace,
EfiKeyIns,
EfiKeyHome,
EfiKeyPgUp,
EfiKeyNLck,
EfiKeySlash,
EfiKeyAsterisk,
EfiKeyMinus,
EfiKeyEsc,
EfiKeyF1,
EfiKeyF2,
EfiKeyF3,
EfiKeyF4,
EfiKeyF5,
EfiKeyF6,
EfiKeyF7,
EfiKeyF8,
EfiKeyF9,
EfiKeyF10,
EfiKeyF11,
EfiKeyF12,
EfiKeyPrint,
EfiKeySLck,
EfiKeyPause
} EFI_KEY;
typedef struct {
EFI_KEY Key;
CHAR16 Unicode;
CHAR16 ShiftedUnicode;
CHAR16 AltGrUnicode;
CHAR16 ShiftedAltGrUnicode;
UINT16 Modifier;
} EFI_KEY_DESCRIPTOR;
//
// This structure allows a sparse set of keys to be redefined
// or a complete redefinition of the keyboard layout. Most
// keyboards have a lot of commonality in their layouts, therefore
// only defining those keys that need to change from the default
// minimizes the passed in information.
//
// Additionally, when an update occurs, the active keyboard layout
// will be switched to the newly updated keyboard layout. This
// allows for situations that when a keyboard layout driver is
// loaded as part of system initialization, the system will default
// the keyboard behavior to the new layout.
//
// Each call to update the keyboard mapping should contain the
// complete set of key descriptors to be updated, since every
// call to the HII which contains an EFI_HII_KEYBOARD_PACK will
// wipe the previous set of overrides. A call to
//
typedef struct {
EFI_HII_PACK_HEADER Header;
EFI_KEY_DESCRIPTOR *Descriptor;
UINT8 DescriptorCount;
} EFI_HII_KEYBOARD_PACK;
//
// The EFI_HII_PACKAGES can contain different types of packages just
// after the structure as inline data.
//
typedef struct {
UINTN NumberOfPackages;
EFI_GUID *GuidId;
//
// EFI_HII_HANDLE_PACK *HandlePack; // Only one pack.
// EFI_HII_IFR_PACK *IfrPack; // Only one pack.
// EFI_HII_FONT_PACK *FontPack[]; // Multiple packs ok
// EFI_HII_STRING_PACK *StringPack[]; // Multiple packs ok
// EFI_HII_KEYBOARD_PACK *KeyboardPack[]; // Multiple packs ok
//
} EFI_HII_PACKAGES;
typedef struct _EFI_HII_VARIABLE_PACK_LIST {
struct _EFI_HII_VARIABLE_PACK_LIST *NextVariablePack;
EFI_HII_VARIABLE_PACK *VariablePack;
} EFI_HII_VARIABLE_PACK_LIST;
#pragma pack()
/**
Registers the various packs that are passed in via the Packages parameter.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Packages A pointer to an EFI_HII_PACKAGES package instance.
@param Handle A pointer to the EFI_HII_HANDLE instance.
@retval EFI_SUCCESS Data was extracted from Packages, the database
was updated with the data, and Handle returned successfully.
@retval EFI_INVALID_PARAMETER The content of Packages was invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_NEW_PACK) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_PACKAGES *Packages,
OUT EFI_HII_HANDLE *Handle
);
/**
Removes a package from the HII database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle that was registered to the data that is requested
for removal.
@retval EFI_SUCCESS The data associated with the Handle was removed
from the HII database.
@retval EFI_INVALID_PARAMETER The Handle was not valid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_REMOVE_PACK) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle
);
/**
Determines the handles that are currently active in the database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param HandleBufferLength On input, a pointer to the length of the handle
buffer. On output, the length of the handle buffer that is required
for the handles found.
@param Handle An array of EFI_HII_HANDLE instances returned.
@retval EFI_SUCCESS Handle was updated successfully.
@retval EFI_BUFFER_TOO_SMALL The HandleBufferLength parameter indicates
that Handle is too small to support the number of handles.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_FIND_HANDLES) (
IN EFI_HII_PROTOCOL *This,
IN OUT UINT16 *HandleBufferLength,
OUT EFI_HII_HANDLE *Handle
);
/**
Exports the contents of the database into a buffer.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle An EFI_HII_HANDLE that corresponds to the desired
handle to export. If the value is 0, the entire database will be exported.
In either case, the data will be exported in a format described by the
structure definition of EFI_HII_EXPORT_TABLE.
@param BufferSize
On input, a pointer to the length of the buffer. On output, the length
of the buffer that is required for the export data.
@param Buffer A pointer to a buffer that will contain the results of the export function.
@retval EFI_SUCCESS The buffer was successfully filled with BufferSize amount of data.
@retval EFI_BUFFER_TOO_SMALL The value in BufferSize was too small to contain the export data.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_EXPORT) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
);
/**
Remove any new strings that were added after the initial string export
for this handle.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the string resides.
@retval EFI_SUCCESS Remove strings from the handle successfully.
@retval EFI_INVALID_PARAMETER The Handle was unknown.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_RESET_STRINGS) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle
);
/**
Tests if all of the characters in a string have corresponding font characters.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param StringToTest A pointer to a Unicode string.
@param FirstMissing A pointer to an index into the string. On input,
the index of the first character in the StringToTest to examine. On exit,
the index of the first character encountered for which a glyph is unavailable.
If all glyphs in the string are available, the index is the index of the
terminator of the string.
@param GlyphBufferSize A pointer to a value. On output, if the function
returns EFI_SUCCESS, it contains the amount of memory that is required to
store the string's glyph equivalent.
@retval EFI_SUCCESS All glyphs are available. Note that an empty string
always returns this value.
@retval EFI_NOT_FOUND A glyph was not found for a character.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_TEST_STRING) (
IN EFI_HII_PROTOCOL *This,
IN CHAR16 *StringToTest,
IN OUT UINT32 *FirstMissing,
OUT UINT32 *GlyphBufferSize
);
/**
Translates a Unicode character into the corresponding font glyph.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Source A pointer to a Unicode string.
@param Index On input, the offset into the string from which to fetch
the character.On successful completion, the index is updated to the first
character past the character(s) making up the just extracted glyph.
@param GlyphBuffer Pointer to an array where the glyphs corresponding
to the characters in the source may be stored. GlyphBuffer is assumed
to be wide enough to accept a wide glyph character.
@param BitWidth If EFI_SUCCESS was returned, the UINT16 pointed to by
this value is filled with the length of the glyph in pixels. It is unchanged
if the call was unsuccessful.
@param InternalStatus The cell pointed to by this parameter must be
initialized to zero prior to invoking the call the first time for any string.
@retval EFI_SUCCESS It worked.
@retval EFI_NOT_FOUND A glyph for a character was not found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_GLYPH) (
IN EFI_HII_PROTOCOL *This,
IN CHAR16 *Source,
IN OUT UINT16 *Index,
OUT UINT8 **GlyphBuffer,
OUT UINT16 *BitWidth,
IN OUT UINT32 *InternalStatus
);
/**
Translates a glyph into the format required for input to the Universal
Graphics Adapter (UGA) Block Transfer (BLT) routines.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param GlyphBuffer A pointer to the buffer that contains glyph data.
@param Foreground The foreground setting requested to be used for the
generated BltBuffer data.
@param Background The background setting requested to be used for the
generated BltBuffer data.
@param Count The entry in the BltBuffer upon which to act.
@param Width The width in bits of the glyph being converted.
@param Height The height in bits of the glyph being converted
@param BltBuffer A pointer to the buffer that contains the data that is
ready to be used by the UGA BLT routines.
@retval EFI_SUCCESS It worked.
@retval EFI_NOT_FOUND A glyph for a character was not found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GLYPH_TO_BLT) (
IN EFI_HII_PROTOCOL *This,
IN UINT8 *GlyphBuffer,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,
IN UINTN Count,
IN UINTN Width,
IN UINTN Height,
IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer
);
/**
Allows a new string to be added to an already existing string package.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Pointer to a NULL-terminated string containing a single ISO 639-2
language identifier, indicating the language in which the string is translated.
@param Handle The handle of the language pack to which the string is to be added.
@param Reference The identifier of the string to be added. If the reference
value is zero, then the string will be assigned a new identifier on that
handle for the language specified. Otherwise, the string will be updated
with the NewString Value.
@param NewString The string to be added.
@retval EFI_SUCCESS The string was effectively registered.
@retval EFI_INVALID_PARAMETER The Handle was unknown.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_NEW_STRING) (
IN EFI_HII_PROTOCOL *This,
IN CHAR16 *Language,
IN EFI_HII_HANDLE Handle,
IN OUT STRING_REF *Reference,
IN CHAR16 *NewString
);
/**
Allows a program to determine the primary languages that are supported
on a given handle.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the strings reside.
@param LanguageString A string allocated by GetPrimaryLanguages() that
contains a list of all primary languages registered on the handle.
@retval EFI_SUCCESS LanguageString was correctly returned.
@retval EFI_INVALID_PARAMETER The Handle was unknown.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_PRI_LANGUAGES) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
OUT EFI_STRING *LanguageString
);
/**
Allows a program to determine which secondary languages are supported
on a given handle for a given primary language.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the strings reside.
@param PrimaryLanguage Pointer to a NULL-terminated string containing a single
ISO 639-2 language identifier, indicating the primary language.
@param LanguageString A string allocated by GetSecondaryLanguages()
containing a list of all secondary languages registered on the handle.
@retval EFI_SUCCESS LanguageString was correctly returned.
@retval EFI_INVALID_PARAMETER The Handle was unknown.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_SEC_LANGUAGES) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN CHAR16 *PrimaryLanguage,
OUT EFI_STRING *LanguageString
);
/**
Extracts a string from a package already registered with the EFI HII database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the string resides.
@param Token The string token assigned to the string.
@param Raw If TRUE, the string is returned unedited in the internal
storage format described above. If false, the string returned is edited
by replacing <cr> with <space> and by removing special characters such
as the <wide> prefix.
@param LanguageString Pointer to a NULL-terminated string containing a
single ISO 639-2 language identifier, indicating the language to print.
If the LanguageString is empty (starts with a NULL), the default system
language will be used to determine the language.
@param BufferLength Length of the StringBuffer.
@param StringBuffer The buffer designed to receive the characters in the string.
@retval EFI_SUCCESS StringBuffer is filled with a NULL-terminated string.
@retval EFI_INVALID_PARAMETER The handle or string token is unknown.
@retval EFI_BUFFER_TOO_SMALL The buffer provided was not large enough to
allow the entire string to be stored.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_STRING) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN STRING_REF Token,
IN BOOLEAN Raw,
IN CHAR16 *LanguageString,
IN OUT UINTN *BufferLength,
OUT EFI_STRING StringBuffer
);
/**
Allows a program to extract a part of a string of not more than a given width.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the string resides.
@param Token The string token assigned to the string.
@param Index On input, the offset into the string where the line is to start.
On output, the index is updated to point to beyond the last character returned
in the call.
@param LineWidth The maximum width of the line in units of narrow glyphs.
@param LanguageString Pointer to a NULL-terminated string containing a
single ISO 639-2 language identifier, indicating the language to print.
@param BufferLength Pointer to the length of the StringBuffer.
@param StringBuffer The buffer designed to receive the characters in the string.
@retval EFI_SUCCESS StringBuffer filled with characters that will fit on the line.
@retval EFI_NOT_FOUND The font glyph for at least one of the characters in
the string is not in the font database.
@retval EFI_BUFFER_TOO_SMALL The buffer provided was not large enough
to allow the entire string to be stored.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_LINE) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN STRING_REF Token,
IN OUT UINT16 *Index,
IN UINT16 LineWidth,
IN CHAR16 *LanguageString,
IN OUT UINT16 *BufferLength,
OUT EFI_STRING StringBuffer
);
/**
Allows a program to extract a form or form package that has previously
been registered with the HII database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle Handle on which the form resides.
@param FormId The ID of the form to return. If the ID is zero,
the entire form package is returned.
@param BufferLength On input, the length of the Buffer. On output,
the length of the returned buffer,
@param Buffer The buffer designed to receive the form(s).
@retval EFI_SUCCESS Buffer filled with the requested forms. BufferLength
was updated.
@retval EFI_INVALID_PARAMETER The handle is unknown.
@retval EFI_NOT_FOUND A form on the requested handle cannot be found with
the requested FormId.
@retval EFI_BUFFER_TOO_SMALL The buffer provided was not large enough
to allow the form to be stored.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_FORMS) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN EFI_FORM_ID FormId,
IN OUT UINTN *BufferLength,
OUT UINT8 *Buffer
);
/**
Extracts the defaults that are associated with a given handle in the HII database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The HII handle from which will have default data retrieved.
@param DefaultMask The mask used to specify some type of default override when extracting
the default image data.
@param VariablePackList A indirect pointer to the first entry of a link list with
type EFI_HII_VARIABLE_PACK_LIST.
@retval EFI_SUCCESS The VariablePackList was populated with the appropriate
default setting data.
@retval EFI_NOT_FOUND The IFR does not have any explicit or default map(s).
@retval EFI_INVALID_PARAMETER The HII database entry associated with Handle
contain invalid data.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_DEFAULT_IMAGE) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN UINTN DefaultMask,
OUT EFI_HII_VARIABLE_PACK_LIST **VariablePackList
);
/**
Allows the caller to update a form or form package that has previously been
registered with the EFI HII database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle Handle of the package where the form to be updated resides.
@param Label The label inside the form package where the update is to take place.
@param AddData If TRUE, adding data at a given Label; otherwise,
if FALSE, removing data at a given Label.
@param Data The buffer containing the new tags to insert after the Label
@retval EFI_SUCCESS The form was updated with the new tags.
@retval EFI_INVALID_PARAMETER The buffer for the buffer length does not
contain an integral number of tags.
@retval EFI_NOT_FOUND The Handle, Label, or FormId was not found.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_UPDATE_FORM) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN EFI_FORM_LABEL Label,
IN BOOLEAN AddData,
IN EFI_HII_UPDATE_DATA *Data
);
/**
Retrieves the current keyboard layout.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param DescriptorCount A pointer to the number of Descriptor entries being
described in the keyboard layout being retrieved.
@param Descriptor A pointer to a buffer containing an array of EFI_KEY_DESCRIPTOR
entries. Each entry will reflect the definition of a specific physical key.
@retval EFI_SUCCESS The keyboard layout was retrieved successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_KEYBOARD_LAYOUT) (
IN EFI_HII_PROTOCOL *This,
OUT UINT16 *DescriptorCount,
OUT EFI_KEY_DESCRIPTOR *Descriptor
);
/**
@par Protocol Description:
The HII Protocol manages the HII database, which is a repository for data
having to do with fonts, strings, forms, keyboards, and other future human
interface items.
@param NewPack
Extracts the various packs from a package list.
@param RemovePack
Removes a package from the HII database.
@param FindHandles
Determines the handles that are currently active in the database.
@param ExportDatabase
Export the entire contents of the database to a buffer.
@param TestString
Tests if all of the characters in a string have corresponding font characters.
@param GetGlyph
Translates a Unicode character into the corresponding font glyph.
@param GlyphToBlt
Converts a glyph value into a format that is ready for a UGA BLT command.
@param NewString
Allows a new string to be added to an already existing string package.
@param GetPrimaryLanguages
Allows a program to determine the primary languages that are supported
on a given handle.
@param GetSecondaryLanguages
Allows a program to determine which secondary languages are supported
on a given handle for a given primary language.
@param GetString
Extracts a string from a package that is already registered with the
EFI HII database.
@param ResetString
Remove any new strings that were added after the initial string export
for this handle.
@param GetLine
Allows a program to extract a part of a string of not more than a given width.
@param GetForms
Allows a program to extract a form or form package that has been previously registered.
@param GetDefaultImage
Allows a program to extract the nonvolatile image that represents the default storage image.
@param UpdateForm
Allows a program to update a previously registered form.
@param GetKeyboardLayout
Allows a program to extract the current keyboard layout.
**/
struct _EFI_HII_PROTOCOL {
EFI_HII_NEW_PACK NewPack;
EFI_HII_REMOVE_PACK RemovePack;
EFI_HII_FIND_HANDLES FindHandles;
EFI_HII_EXPORT ExportDatabase;
EFI_HII_TEST_STRING TestString;
EFI_HII_GET_GLYPH GetGlyph;
EFI_HII_GLYPH_TO_BLT GlyphToBlt;
EFI_HII_NEW_STRING NewString;
EFI_HII_GET_PRI_LANGUAGES GetPrimaryLanguages;
EFI_HII_GET_SEC_LANGUAGES GetSecondaryLanguages;
EFI_HII_GET_STRING GetString;
EFI_HII_RESET_STRINGS ResetStrings;
EFI_HII_GET_LINE GetLine;
EFI_HII_GET_FORMS GetForms;
EFI_HII_GET_DEFAULT_IMAGE GetDefaultImage;
EFI_HII_UPDATE_FORM UpdateForm;
EFI_HII_GET_KEYBOARD_LAYOUT GetKeyboardLayout;
};
extern EFI_GUID gEfiHiiProtocolGuid;
#endif

455
IntelFrameworkPkg/Include/Protocol/IdeControllerInit.h Normal file
View File

@@ -0,0 +1,455 @@
/** @file
This file declares EFI IDE Controller Init Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: IdeControllerInit.h
@par Revision Reference:
This Protocol is defined in IDE Controller Initialization Protocol Specification
Version 0.9
**/
#ifndef _EFI_IDE_CONTROLLER_INIT_PROTOCOL_H_
#define _EFI_IDE_CONTROLLER_INIT_PROTOCOL_H_
//
// Global ID for the EFI Platform IDE Protocol GUID
//
#define EFI_IDE_CONTROLLER_INIT_PROTOCOL_GUID \
{ 0xa1e37052, 0x80d9, 0x4e65, {0xa3, 0x17, 0x3e, 0x9a, 0x55, 0xc4, 0x3e, 0xc9 } }
//
// Forward reference for pure ANSI compatability
//
typedef struct _EFI_IDE_CONTROLLER_INIT_PROTOCOL EFI_IDE_CONTROLLER_INIT_PROTOCOL;
//
//////////////////////////////////////////////////////////////////////////////////////////
// EFI_IDE_BUS_ENUMERATION_PHASE
// EFI_IDE_CONTROLLER_ENUM_PHASE
//
typedef enum{
EfiIdeBeforeChannelEnumeration,
EfiIdeAfterChannelEnumeration,
EfiIdeBeforeChannelReset,
EfiIdeAfterChannelReset,
EfiIdeBusBeforeDevicePresenceDetection,
EfiIdeBusAfterDevicePresenceDetection,
EfiIdeResetMode,
EfiIdeBusPhaseMaximum
} EFI_IDE_CONTROLLER_ENUM_PHASE;
//
//******************************************************
// EFI_ATA_EXT_TRANSFER_PROTOCOL
//******************************************************
//
// This extended mode describes the SATA physical protocol.
// SATA physical layers can operate at different speeds.
// These speeds are defined below. Various PATA protocols
// and associated modes are not applicable to SATA devices.
//
typedef enum {
EfiAtaSataTransferProtocol
} EFI_ATA_EXT_TRANSFER_PROTOCOL;
#define EFI_SATA_AUTO_SPEED 0
#define EFI_SATA_GEN1_SPEED 1
#define EFI_SATA_GEN2_SPEED 2
//
//*******************************************************
// EFI_IDE_CABLE_TYPE
//*******************************************************
//
typedef enum {
EfiIdeCableTypeUnknown,
EfiIdeCableType40pin,
EfiIdeCableType80Pin,
EfiIdeCableTypeSerial,
EfiIdeCableTypeMaximum
} EFI_IDE_CABLE_TYPE;
//
//******************************************************
// EFI_ATA_MODE
//******************************************************
//
typedef struct {
BOOLEAN Valid;
UINT32 Mode;
} EFI_ATA_MODE;
//
//******************************************************
// EFI_ATA_EXTENDED_MODE
//******************************************************
//
typedef struct {
EFI_ATA_EXT_TRANSFER_PROTOCOL TransferProtocol;
UINT32 Mode;
} EFI_ATA_EXTENDED_MODE;
//
//******************************************************
// EFI_ATA_COLLECTIVE_MODE
//******************************************************
//
typedef struct {
EFI_ATA_MODE PioMode;
EFI_ATA_MODE SingleWordDmaMode;
EFI_ATA_MODE MultiWordDmaMode;
EFI_ATA_MODE UdmaMode;
UINT32 ExtModeCount;
EFI_ATA_EXTENDED_MODE ExtMode[1];
} EFI_ATA_COLLECTIVE_MODE;
//
//*******************************************************
// EFI_ATA_IDENTIFY_DATA
//*******************************************************
//
#pragma pack(1)
typedef struct {
UINT16 config; // General Configuration
UINT16 cylinders; // Number of Cylinders
UINT16 reserved_2;
UINT16 heads; //Number of logical heads
UINT16 vendor_data1;
UINT16 vendor_data2;
UINT16 sectors_per_track;
UINT16 vendor_specific_7_9[3];
CHAR8 SerialNo[20]; // ASCII
UINT16 vendor_specific_20_21[2];
UINT16 ecc_bytes_available;
CHAR8 FirmwareVer[8]; // ASCII
CHAR8 ModelName[40]; // ASCII
UINT16 multi_sector_cmd_max_sct_cnt;
UINT16 reserved_48;
UINT16 capabilities;
UINT16 reserved_50;
UINT16 pio_cycle_timing;
UINT16 reserved_52;
UINT16 field_validity;
UINT16 current_cylinders;
UINT16 current_heads;
UINT16 current_sectors;
UINT16 CurrentCapacityLsb;
UINT16 CurrentCapacityMsb;
UINT16 reserved_59;
UINT16 user_addressable_sectors_lo;
UINT16 user_addressable_sectors_hi;
UINT16 reserved_62;
UINT16 multi_word_dma_mode;
UINT16 advanced_pio_modes;
UINT16 min_multi_word_dma_cycle_time;
UINT16 rec_multi_word_dma_cycle_time;
UINT16 min_pio_cycle_time_without_flow_control;
UINT16 min_pio_cycle_time_with_flow_control;
UINT16 reserved_69_79[11];
UINT16 major_version_no;
UINT16 minor_version_no;
UINT16 command_set_supported_82; // word 82
UINT16 command_set_supported_83; // word 83
UINT16 command_set_feature_extn; // word 84
UINT16 command_set_feature_enb_85; // word 85
UINT16 command_set_feature_enb_86; // word 86
UINT16 command_set_feature_default; // word 87
UINT16 ultra_dma_mode; // word 88
UINT16 reserved_89_127[39];
UINT16 security_status;
UINT16 vendor_data_129_159[31];
UINT16 reserved_160_255[96];
} EFI_ATA_IDENTIFY_DATA;
#pragma pack()
//
//*******************************************************
// EFI_ATAPI_IDENTIFY_DATA
//*******************************************************
//
#pragma pack(1)
typedef struct {
UINT16 config; // General Configuration
UINT16 obsolete_1;
UINT16 specific_config;
UINT16 obsolete_3;
UINT16 retired_4_5[2];
UINT16 obsolete_6;
UINT16 cfa_reserved_7_8[2];
UINT16 retired_9;
CHAR8 SerialNo[20]; // ASCII
UINT16 retired_20_21[2];
UINT16 obsolete_22;
CHAR8 FirmwareVer[8]; // ASCII
CHAR8 ModelName[40]; // ASCII
UINT16 multi_sector_cmd_max_sct_cnt;
UINT16 reserved_48;
UINT16 capabilities_49;
UINT16 capabilities_50;
UINT16 obsolete_51_52[2];
UINT16 field_validity;
UINT16 obsolete_54_58[5];
UINT16 mutil_sector_setting;
UINT16 user_addressable_sectors_lo;
UINT16 user_addressable_sectors_hi;
UINT16 obsolete_62;
UINT16 multi_word_dma_mode;
UINT16 advanced_pio_modes;
UINT16 min_multi_word_dma_cycle_time;
UINT16 rec_multi_word_dma_cycle_time;
UINT16 min_pio_cycle_time_without_flow_control;
UINT16 min_pio_cycle_time_with_flow_control;
UINT16 reserved_69_74[6];
UINT16 queue_depth;
UINT16 reserved_76_79[4];
UINT16 major_version_no;
UINT16 minor_version_no;
UINT16 cmd_set_support_82;
UINT16 cmd_set_support_83;
UINT16 cmd_feature_support;
UINT16 cmd_feature_enable_85;
UINT16 cmd_feature_enable_86;
UINT16 cmd_feature_default;
UINT16 ultra_dma_select;
UINT16 time_required_for_sec_erase;
UINT16 time_required_for_enhanced_sec_erase;
UINT16 current_advanced_power_mgmt_value;
UINT16 master_pwd_revison_code;
UINT16 hardware_reset_result;
UINT16 current_auto_acoustic_mgmt_value;
UINT16 reserved_95_99[5];
UINT16 max_user_lba_for_48bit_addr[4];
UINT16 reserved_104_126[23];
UINT16 removable_media_status_notification_support;
UINT16 security_status;
UINT16 vendor_data_129_159[31];
UINT16 cfa_power_mode;
UINT16 cfa_reserved_161_175[15];
UINT16 current_media_serial_no[30];
UINT16 reserved_206_254[49];
UINT16 integrity_word;
} EFI_ATAPI_IDENTIFY_DATA;
#pragma pack()
//
//*******************************************************
// EFI_IDENTIFY_DATA
//*******************************************************
//
typedef union {
EFI_ATA_IDENTIFY_DATA AtaData;
EFI_ATAPI_IDENTIFY_DATA AtapiData;
} EFI_IDENTIFY_DATA;
#define EFI_ATAPI_DEVICE_IDENTIFY_DATA 0x8000
//
/////////////////////////////////////////////////////////////////////////////////////////
// Function prototype declaration, for ANSI compatability
//
/**
Returns the information about the specified IDE channel.
@param This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param Channel Zero-based channel number.
@param Enabled TRUE if this channel is enabled. Disabled channels are not scanned
to see if any devices are present.
@param MaxDevices The maximum number of IDE devices that the bus driver
can expect on this channel.
@retval EFI_SUCCESS Information was returned without any errors.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
**/
typedef
EFI_STATUS
(EFIAPI *EFI_IDE_CONTROLLER_GET_CHANNEL_INFO) (
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
IN UINT8 Channel,
OUT BOOLEAN *Enabled,
OUT UINT8 *MaxDevices
);
/**
The notifications from the IDE bus driver that it is about to enter a certain
phase of the IDE channel enumeration process.
@param This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param Phase The phase during enumeration.
@param Channel Zero-based channel number.
@retval EFI_SUCCESS The notification was accepted without any errors.
@retval EFI_NOT_SUPPORTED Phase is not supported.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
@retval EFI_NOT_READY This phase cannot be entered at this time.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_IDE_CONTROLLER_NOTIFY_PHASE) (
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
IN EFI_IDE_CONTROLLER_ENUM_PHASE Phase,
IN UINT8 Channel
);
/**
Submits the device information to the IDE controller driver.
@param This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param Channel Zero-based channel number.
@param Device Zero-based device number on the Channel.
@param IdentifyData The device's response to the ATA IDENTIFY_DEVICE command.
@retval EFI_SUCCESS The information was accepted without any errors.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
Or Device is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_IDE_CONTROLLER_SUBMIT_DATA) (
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
IN UINT8 Channel,
IN UINT8 Device,
IN EFI_IDENTIFY_DATA *IdentifyData
);
/**
Disqualifies specific modes for an IDE device.
@param This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param Channel Zero-based channel number.
@param Device Zero-based device number on the Channel.
@param BadModes The modes that the device does not support and that
should be disqualified.
@retval EFI_SUCCESS The modes were accepted without any errors.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
Or Device is invalid.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_IDE_CONTROLLER_DISQUALIFY_MODE) (
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
IN UINT8 Channel,
IN UINT8 Device,
IN EFI_ATA_COLLECTIVE_MODE *BadModes
);
/**
Returns the information about the optimum modes for the specified IDE device.
@param This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param Channel Zero-based channel number.
@param Device Zero-based device number on the Channel.
@param SupportedModes The optimum modes for the device.
@retval EFI_SUCCESS SupportedModes was returned.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
Or Device is invalid. Or SupportedModes is NULL.
@retval EFI_NOT_READY Modes cannot be calculated due to a lack of data.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_IDE_CONTROLLER_CALCULATE_MODE) (
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
IN UINT8 Channel,
IN UINT8 Device,
OUT EFI_ATA_COLLECTIVE_MODE **SupportedModes
);
/**
Commands the IDE controller driver to program the IDE controller hardware
so that the specified device can operate at the specified mode.
@param This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param Channel Zero-based channel number.
@param Device Zero-based device number on the Channel.
@param Modes The modes to set.
@retval EFI_SUCCESS The command was accepted without any errors.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
Or Device is invalid.
@retval EFI_NOT_READY Modes cannot be set at this time due to lack of data.
@retval EFI_DEVICE_ERROR Modes cannot be set due to hardware failure.
The IDE bus driver should not use this device.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_IDE_CONTROLLER_SET_TIMING) (
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
IN UINT8 Channel,
IN UINT8 Device,
IN EFI_ATA_COLLECTIVE_MODE *Modes
);
//
////////////////////////////////////////////////////////////////////////////////////////////////////
// Interface structure
// EFI_IDE_CONTROLLER_INIT_PROTOCOL protocol provides the chipset specific information to the IDE bus driver.
// An IDE Bus driver wants to manage an IDE bus and possible IDE devices will have to retrieve the
// EFI_IDE_CONTROLLER_INIT_PROTOCOL instances.
//
/**
@par Protocol Description:
Provides the basic interfaces to abstract an IDE controller.
@param GetChannelInfo
Returns the information about a specific channel.
@param NotifyPhase
The notification that the IDE bus driver is about to enter the
specified phase during the enumeration process.
@param SubmitData
Submits the Drive Identify data that was returned by the device.
@param DisqualifyMode
Submits information about modes that should be disqualified.
@param CalculateMode
Calculates and returns the optimum mode for a particular IDE device.
@param SetTiming
Programs the IDE controller hardware to the default timing or per the modes
that were returned by the last call to CalculateMode().
@param EnumAll
Set to TRUE if the enumeration group includes all the channels that are
produced by this controller. FALSE if an enumeration group consists of
only one channel.
@param ChannelCount
The number of channels that are produced by this controller.
**/
struct _EFI_IDE_CONTROLLER_INIT_PROTOCOL {
EFI_IDE_CONTROLLER_GET_CHANNEL_INFO GetChannelInfo;
EFI_IDE_CONTROLLER_NOTIFY_PHASE NotifyPhase;
EFI_IDE_CONTROLLER_SUBMIT_DATA SubmitData;
EFI_IDE_CONTROLLER_DISQUALIFY_MODE DisqualifyMode;
EFI_IDE_CONTROLLER_CALCULATE_MODE CalculateMode;
EFI_IDE_CONTROLLER_SET_TIMING SetTiming;
BOOLEAN EnumAll;
UINT8 ChannelCount;
};
extern EFI_GUID gEfiIdeControllerInitProtocolGuid;
#endif

78
IntelFrameworkPkg/Include/Protocol/IncompatiblePciDeviceSupport.h Normal file
View File

@@ -0,0 +1,78 @@
/** @file
This file declares EFI Incompatible PCI Device Support Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: IncompatiblePciDeviceSupport.h
@par Revision Reference:
This protocol is defined in Framework of EFI PCI Platform Support Specification.
Version0.9
**/
#ifndef _INCOMPATIBLE_PCI_DEVICE_SUPPORT_H_
#define _INCOMPATIBLE_PCI_DEVICE_SUPPORT_H_
#define EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL_GUID \
{0xeb23f55a, 0x7863, 0x4ac2, {0x8d, 0x3d, 0x95, 0x65, 0x35, 0xde, 0x03, 0x75} }
typedef struct _EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL;
/**
Returns a list of ACPI resource descriptors that detail the special
resource configuration requirements for an incompatible PCI device.
@param This Pointer to the EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL instance.
@param VendorID A unique ID to identify the manufacturer of the PCI device.
@param DeviceID A unique ID to identify the particular PCI device.
@param RevisionID A PCI device-specific revision identifier.
@param SubsystemVendorId Specifies the subsystem vendor ID.
@param SubsystemDeviceId Specifies the subsystem device ID.
@param Configuration A list of ACPI resource descriptors that detail
the configuration requirement.
@retval EFI_SUCCESS The function always returns EFI_SUCCESS.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_CHECK_DEVICE) (
IN EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL *This,
IN UINTN VendorId,
IN UINTN DeviceId,
IN UINTN Revision,
IN UINTN SubVendorId,OPTIONAL
IN UINTN SubDeviceId,OPTIONAL
OUT VOID **Configuration
);
//
// Interface structure for the Incompatible PCI Device Support Protocol
//
/**
@par Protocol Description:
This protocol can find some incompatible PCI devices and report their
special resource requirements to the PCI bus driver.
@param CheckDevice
Returns a list of ACPI resource descriptors that detail any special
resource configuration requirements if the specified device is a recognized
incompatible PCI device.
**/
struct _EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL {
EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_CHECK_DEVICE CheckDevice;
};
extern EFI_GUID gEfiIncompatiblePciDeviceSupportProtocolGuid;
#endif

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

@@ -0,0 +1,298 @@
/** @file
This protocol abstracts the 8259 interrupt controller. This includes
PCI IRQ routing need to program the PCI Interrupt Line register.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: Legacy8259.h
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.96
**/
#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 Protocol instance pointer.
@param MasterBase The base vector for the Master PIC in the 8259 controller
@param Slavebase The base vector for the Master PIC in the 8259 controller
@retval EFI_SUCCESS The new bases were programmed
@retval EFI_DEVICE_ERROR A device erro 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 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 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_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 Protocol instance pointer.
@param Mode Mode of operation. i.e. 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 writting 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 Protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15
@param Vector Processor vector number that matches Irq
@retval EFI_SUCCESS The Vector matching Irq is returned
@retval EFI_INVALID_PARAMETER 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 Protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15
@param LevelTriggered TRUE if level triggered. FALSE if edge triggered.
@retval EFI_SUCCESS Irq enabled on 8259
@retval EFI_INVALID_PARAMETER Irq 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 Protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15
@retval EFI_SUCCESS Irq disabled on 8259
@retval EFI_INVALID_PARAMETER Irq 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 Protocol instance pointer.
@param PciHandle PCI function to return vector for
@param Vector Vector for fucntion that matches
@retval EFI_SUCCESS A valid Vector is 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 Protocol instance pointer.
@param Irq 8259 IRQ0 - IRQ15
@retval EFI_SUCCESS EOI successfully sent to 8259
@retval EFI_INVALID_PARAMETER Irq not 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

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

@@ -0,0 +1,524 @@
/** @file
The EFI Legacy BIOS Protocol is used to abstract legacy Option ROM usage
under EFI and Legacy OS boot.
Note: The names for EFI_IA32_REGISTER_SET elements were picked to follow
well known naming conventions.
Thunk - A thunk is a transition from one processor mode to another. A Thunk
is a transition from native EFI mode to 16-bit mode. A reverse thunk
would be a transition from 16-bit mode to native EFI mode.
You most likely should not use this protocol! Find the EFI way to solve the
problem to make your code portable
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: LegacyBios.h
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.96
**/
#ifndef _EFI_LEGACY_BIOS_H_
#define _EFI_LEGACY_BIOS_H_
#define EFI_LEGACY_BIOS_PROTOCOL_GUID \
{ \
0xdb9a1e3d, 0x45cb, 0x4abb, {0x85, 0x3b, 0xe5, 0x38, 0x7f, 0xdb, 0x2e, 0x2d } \
}
typedef struct _EFI_LEGACY_BIOS_PROTOCOL EFI_LEGACY_BIOS_PROTOCOL;
//
/// @bug: These macros appear in no specifications and are kept for backward
// compatibility only.
// Convert from 32-bit address (_Adr) to Segment:Offset 16-bit form
//
#define EFI_SEGMENT(_Adr) (UINT16) ((UINT16) (((UINTN) (_Adr)) >> 4) & 0xf000)
#define EFI_OFFSET(_Adr) (UINT16) (((UINT16) ((UINTN) (_Adr))) & 0xffff)
#define BYTE_GRANULARITY 0x01
#define WORD_GRANULARITY 0x02
#define DWORD_GRANULARITY 0x04
#define QWORD_GRANULARITY 0x08
#define PARAGRAPH_GRANULARITY 0x10
#define CARRY_FLAG 0x01
//*********************************************************
// EFI_EFLAGS_REG
//*********************************************************
typedef struct {
UINT32 CF:1;
UINT32 Reserved1:1;
UINT32 PF:1;
UINT32 Reserved2:1;
UINT32 AF:1;
UINT32 Reserved3:1;
UINT32 ZF:1;
UINT32 SF:1;
UINT32 TF:1;
UINT32 IF:1;
UINT32 DF:1;
UINT32 OF:1;
UINT32 IOPL:2;
UINT32 NT:1;
UINT32 Reserved4:2;
UINT32 VM:1;
UINT32 Reserved5:14;
} EFI_EFLAGS_REG;
//*********************************************************
// EFI_DWORD_REGS
//*********************************************************
typedef struct {
UINT32 EAX;
UINT32 EBX;
UINT32 ECX;
UINT32 EDX;
UINT32 ESI;
UINT32 EDI;
EFI_EFLAGS_REG EFlags;
UINT16 ES;
UINT16 CS;
UINT16 SS;
UINT16 DS;
UINT16 FS;
UINT16 GS;
UINT32 EBP;
UINT32 ESP;
} EFI_DWORD_REGS;
//*******************************************
// EFI_FLAGS_REG
//*******************************************
typedef struct {
UINT16 CF:1;
UINT16 Reserved1:1;
UINT16 PF:1;
UINT16 Reserved2:1;
UINT16 AF:1;
UINT16 Reserved3:1;
UINT16 ZF:1;
UINT16 SF:1;
UINT16 TF:1;
UINT16 IF:1;
UINT16 DF:1;
UINT16 OF:1;
UINT16 IOPL:2;
UINT16 NT:1;
UINT16 Reserved4:1;
} EFI_FLAGS_REG;
//*********************************************************
// EFI_WORD_REGS
//*********************************************************
typedef struct {
UINT16 AX;
UINT16 ReservedAX;
UINT16 BX;
UINT16 ReservedBX;
UINT16 CX;
UINT16 ReservedCX;
UINT16 DX;
UINT16 ReservedDX;
UINT16 SI;
UINT16 ReservedSI;
UINT16 DI;
UINT16 ReservedDI;
EFI_FLAGS_REG Flags;
UINT16 ReservedFlags;
UINT16 ES;
UINT16 CS;
UINT16 SS;
UINT16 DS;
UINT16 FS;
UINT16 GS;
UINT16 BP;
UINT16 ReservedBP;
UINT16 SP;
UINT16 ReservedSP;
} EFI_WORD_REGS;
//*********************************************************
// EFI_BYTE_REGS
//*********************************************************
typedef struct {
UINT8 AL, AH;
UINT16 ReservedAX;
UINT8 BL, BH;
UINT16 ReservedBX;
UINT8 CL, CH;
UINT16 ReservedCX;
UINT8 DL, DH;
UINT16 ReservedDX;
} EFI_BYTE_REGS;
typedef union {
EFI_DWORD_REGS E;
EFI_WORD_REGS X;
EFI_BYTE_REGS H;
} EFI_IA32_REGISTER_SET;
/**
Thunk to 16-bit real mode and execute a software interrupt with a vector
of BiosInt. Regs will contain the 16-bit register context on entry and
exit.
@param This Protocol instance pointer.
@param BiosInt Processor interrupt vector to invoke
@param Reg Register contexted passed into (and returned) from thunk to
16-bit mode
@retval FALSE Thunk completed, and there were no BIOS errors in the target code.
See Regs for status.
@retval TRUE There was a BIOS erro in the target code.
**/
typedef
BOOLEAN
(EFIAPI *EFI_LEGACY_BIOS_INT86) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN UINT8 BiosInt,
IN OUT EFI_IA32_REGISTER_SET *Regs
);
/**
Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the
16-bit register context on entry and exit. Arguments can be passed on
the Stack argument
@param This Protocol instance pointer.
@param Segment Segemnt of 16-bit mode call
@param Offset Offset of 16-bit mdoe call
@param Reg Register contexted passed into (and returned) from thunk to
16-bit mode
@param Stack Caller allocated stack used to pass arguments
@param StackSize Size of Stack in bytes
@retval FALSE Thunk completed, and there were no BIOS errors in the target code.
See Regs for status.
@retval TRUE There was a BIOS erro in the target code.
**/
typedef
BOOLEAN
(EFIAPI *EFI_LEGACY_BIOS_FARCALL86) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN UINT16 Segment,
IN UINT16 Offset,
IN EFI_IA32_REGISTER_SET *Regs,
IN VOID *Stack,
IN UINTN StackSize
);
/**
Test to see if a legacy PCI ROM exists for this device. Optionally return
the Legacy ROM instance for this PCI device.
@param This Protocol instance pointer.
@param PciHandle The PCI PC-AT OPROM from this devices ROM BAR will be loaded
@param RomImage Return the legacy PCI ROM for this device
@param RomSize Size of ROM Image
@param Flags Indicates if ROM found and if PC-AT.
@retval EFI_SUCCESS Legacy Option ROM availible for this device
@retval EFI_UNSUPPORTED Legacy Option ROM not supported.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_CHECK_ROM) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN EFI_HANDLE PciHandle,
OUT VOID **RomImage, OPTIONAL
OUT UINTN *RomSize, OPTIONAL
OUT UINTN *Flags
);
/**
Load a legacy PC-AT OPROM on the PciHandle device. Return information
about how many disks were added by the OPROM and the shadow address and
size. DiskStart & DiskEnd are INT 13h drive letters. Thus 0x80 is C:
@param This Protocol instance pointer.
@param PciHandle The PCI PC-AT OPROM from this devices ROM BAR will be loaded.
This value is NULL if RomImage is non-NULL. This is the normal
case.
@param RomImage A PCI PC-AT ROM image. This argument is non-NULL if there is
no hardware associated with the ROM and thus no PciHandle,
otherwise is must be NULL.
Example is PXE base code.
@param Flags Return Status if ROM was found and if was Legacy OPROM.
@param DiskStart Disk number of first device hooked by the ROM. If DiskStart
is the same as DiskEnd no disked were hooked.
@param DiskEnd Disk number of the last device hooked by the ROM.
@param RomShadowAddress Shadow address of PC-AT ROM
@param RomShadowSize Size of RomShadowAddress in bytes
@retval EFI_SUCCESS Thunk completed, see Regs for status.
@retval EFI_INVALID_PARAMETER PciHandle not found
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_INSTALL_ROM) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN EFI_HANDLE PciHandle,
IN VOID **RomImage,
OUT UINTN *Flags,
OUT UINT8 *DiskStart, OPTIONAL
OUT UINT8 *DiskEnd, OPTIONAL
OUT VOID **RomShadowAddress, OPTIONAL
OUT UINT32 *ShadowedRomSize OPTIONAL
);
/**
Attempt to legacy boot the BootOption. If the EFI contexted has been
compromised this function will not return.
@param This Protocol instance pointer.
@param BootOption EFI Device Path from BootXXXX variable.
@param LoadOptionSize Size of LoadOption in size.
@param LoadOption LoadOption from BootXXXX variable
@retval EFI_SUCCESS Removable media not present
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_BOOT) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN BBS_BBS_DEVICE_PATH *BootOption,
IN UINT32 LoadOptionsSize,
IN VOID *LoadOptions
);
/**
Update BDA with current Scroll, Num & Cap lock LEDS
@param This Protocol instance pointer.
@param Leds Status of current Scroll, Num & Cap lock LEDS
Bit 0 is Scroll Lock 0 = Not locked
Bit 1 is Num Lock
Bit 2 is Caps Lock
@retval EFI_SUCCESS Removable media not present
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_UPDATE_KEYBOARD_LED_STATUS) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN UINT8 Leds
);
/**
Retrieve legacy BBS info and assign boot priority.
@param This Protocol instance pointer.
@param HddCount Number of HDD_INFO structures
@param HddInfo Onboard IDE controller information
@param BbsCount Number of BBS_TABLE structures
@param BbsTable List BBS entries
@retval EFI_SUCCESS Tables returned
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_GET_BBS_INFO) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
OUT UINT16 *HddCount,
OUT HDD_INFO **HddInfo,
OUT UINT16 *BbsCount,
IN OUT BBS_TABLE **BbsTable
);
/**
Assign drive number to legacy HDD drives prior to booting an EFI
aware OS so the OS can access drives without an EFI driver.
@param This Protocol instance pointer.
@param BbsCount Number of BBS_TABLE structures
@param BbsTable List BBS entries
@retval EFI_SUCCESS Drive numbers assigned
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PREPARE_TO_BOOT_EFI) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
OUT UINT16 *BbsCount,
OUT BBS_TABLE **BbsTable
);
/**
To boot from an unconventional device like parties and/or execute
HDD diagnostics.
@param This Protocol instance pointer.
@param Attributes How to interpret the other input parameters
@param BbsEntry The 0-based index into the BbsTable for the parent
device.
@param BeerData Pointer to the 128 bytes of ram BEER data.
@param ServiceAreaData Pointer to the 64 bytes of raw Service Area data. The
caller must provide a pointer to the specific Service
Area and not the start all Service Areas.
EFI_INVALID_PARAMETER if error. Does NOT return if no error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_BOOT_UNCONVENTIONAL_DEVICE) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN UDC_ATTRIBUTES Attributes,
IN UINTN BbsEntry,
IN VOID *BeerData,
IN VOID *ServiceAreaData
);
/**
Shadow all legacy16 OPROMs that haven't been shadowed.
Warning: Use this with caution. This routine disconnects all EFI
drivers. If used externally then caller must re-connect EFI
drivers.
@retval EFI_SUCCESS OPROMs shadowed
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_SHADOW_ALL_LEGACY_OPROMS) (
IN EFI_LEGACY_BIOS_PROTOCOL *This
);
/**
Get a region from the LegacyBios for S3 usage.
@param This Protocol instance pointer.
@param LegacyMemorySize Size of required region
@param Region Region to use.
00 = Either 0xE0000 or 0xF0000 block
Bit0 = 1 0xF0000 block
Bit1 = 1 0xE0000 block
@param Alignment Address alignment. Bit mapped. First non-zero
bit from right is alignment.
@param LegacyMemoryAddress Region Assigned
@retval EFI_SUCCESS Region assigned
@retval Other Region not assigned
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_GET_LEGACY_REGION) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN UINTN LegacyMemorySize,
IN UINTN Region,
IN UINTN Alignment,
OUT VOID **LegacyMemoryAddress
);
/**
Get a region from the LegacyBios for Tiano usage. Can only be invoked once.
@param This Protocol instance pointer.
@param LegacyMemorySize Size of data to copy
@param LegacyMemoryAddress Legacy Region destination address
Note: must be in region assigned by
LegacyBiosGetLegacyRegion
@param LegacyMemorySourceAddress
Source of data
@retval EFI_SUCCESS Region assigned
@retval EFI_ACCESS_DENIED Destination outside assigned region
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_COPY_LEGACY_REGION) (
IN EFI_LEGACY_BIOS_PROTOCOL *This,
IN UINTN LegacyMemorySize,
IN VOID *LegacyMemoryAddress,
IN VOID *LegacyMemorySourceAddress
);
/**
@par Protocol Description:
Abstracts the traditional BIOS from the rest of EFI. The LegacyBoot()
member function allows the BDS to support booting a traditional OS.
EFI thunks drivers that make EFI bindings for BIOS INT services use
all the other member functions.
@param Int86
Performs traditional software INT. See the Int86() function description.
@param FarCall86
Performs a far call into Compatibility16 or traditional OpROM code.
@param CheckPciRom
Checks if a traditional OpROM exists for this device.
@param InstallPciRom
Loads a traditional OpROM in traditional OpROM address space.
@param LegacyBoot
Boots a traditional OS.
@param UpdateKeyboardLedStatus
Updates BDA to reflect the current EFI keyboard LED status.
@param GetBbsInfo
Allows an external agent, such as BIOS Setup, to get the BBS data.
@param ShadowAllLegacyOproms
Causes all legacy OpROMs to be shadowed.
@param PrepareToBootEfi
Performs all actions prior to boot. Used when booting an EFI-aware OS
rather than a legacy OS.
@param GetLegacyRegion
Allows EFI to reserve an area in the 0xE0000 or 0xF0000 block.
@param CopyLegacyRegion
Allows EFI to copy data to the area specified by GetLegacyRegion.
@param BootUnconventionalDevice
Allows the user to boot off an unconventional device such as a PARTIES partition.
**/
struct _EFI_LEGACY_BIOS_PROTOCOL {
EFI_LEGACY_BIOS_INT86 Int86;
EFI_LEGACY_BIOS_FARCALL86 FarCall86;
EFI_LEGACY_BIOS_CHECK_ROM CheckPciRom;
EFI_LEGACY_BIOS_INSTALL_ROM InstallPciRom;
EFI_LEGACY_BIOS_BOOT LegacyBoot;
EFI_LEGACY_BIOS_UPDATE_KEYBOARD_LED_STATUS UpdateKeyboardLedStatus;
EFI_LEGACY_BIOS_GET_BBS_INFO GetBbsInfo;
EFI_LEGACY_BIOS_SHADOW_ALL_LEGACY_OPROMS ShadowAllLegacyOproms;
EFI_LEGACY_BIOS_PREPARE_TO_BOOT_EFI PrepareToBootEfi;
EFI_LEGACY_BIOS_GET_LEGACY_REGION GetLegacyRegion;
EFI_LEGACY_BIOS_COPY_LEGACY_REGION CopyLegacyRegion;
EFI_LEGACY_BIOS_BOOT_UNCONVENTIONAL_DEVICE BootUnconventionalDevice;
};
extern EFI_GUID gEfiLegacyBiosProtocolGuid;
#endif

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

@@ -0,0 +1,281 @@
/** @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, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: LegacyBiosPlatform.h
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.96
**/
#ifndef _EFI_LEGACY_BIOS_PLATFORM_H_
#define _EFI_LEGACY_BIOS_PLATFORM_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;
typedef enum {
EfiGetPlatformBinaryMpTable = 0,
EfiGetPlatformBinaryOemIntData = 1,
EfiGetPlatformBinaryOem16Data = 2,
EfiGetPlatformBinaryOem32Data = 3,
EfiGetPlatformBinaryTpmBinary = 4,
EfiGetPlatformBinarySystemRom = 5,
EfiGetPlatformPciExpressBase = 6,
EfiGetPlatformPmmSize = 7,
EfiGetPlatformEndOpromShadowAddr = 8,
} EFI_GET_PLATFORM_INFO_MODE;
typedef enum {
EfiGetPlatformVgaHandle = 0,
EfiGetPlatformIdeHandle = 1,
EfiGetPlatformIsaBusHandle = 2,
EfiGetPlatformUsbHandle = 3
} EFI_GET_PLATFORM_HANDLE_MODE;
typedef enum {
EfiPlatformHookPrepareToScanRom = 0,
EfiPlatformHookShadowServiceRoms= 1,
EfiPlatformHookAfterRomInit = 2
} EFI_GET_PLATFORM_HOOK_MODE;
/**
Finds the binary data or other platform information.
@param This Protocol instance pointer.
@param Mode Specifies what data to return
@param Table Pointer to MP table.
@param TableSize Size in bytes of table.
@param Location Legacy region requested
0x00 = Any location
Bit 0 = 0xF0000 region
Bit 1 = 0xE0000 region
Multiple bits can be set
@param Alignment Address alignment for allocation.
Bit mapped. First non-zero bit from right
is alignment.
@param LegacySegment Segment in LegacyBios where Table is stored
@param LegacyOffset Offset in LegacyBios where Table is stored
@retval EFI_SUCCESS Data was 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 sub-function.
@param This Protocol instance pointer.
@param Mode Specifies what handle to return.
@param Type Type from Device Path for Handle to represent.
@param HandleBuffer Handles of the device/controller in priority order
with HandleBuffer[0] highest priority.
@param HandleCount Number of handles in the buffer.
@param AdditionalData Mode specific.
@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 Protocol instance pointer.
@param EfiToLegacy16BootTable 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.
@param This Protocol instance pointer.
@param Mode Specifies what handle to return.
@param Type Mode specific.
@param DeviceHandle List of PCI devices in the system.
@param ShadowAddress First free OpROM area, after other OpROMs have been dispatched.
@param Compatibility16Table Pointer to Compatibility16Table.
@param AdditionalData Mode specific Pointer to additional data returned - mode specific.
@retval EFI_SUCCESS RomImage is valid
@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,
IN OUT UINTN *ShadowAddress,
IN EFI_COMPATIBILITY16_TABLE *Compatibility16Table,
IN VOID **AdditionalData OPTIONAL
);
/**
Returns information associated with PCI IRQ routing.
@param This Protocol instance pointer.
@param RoutingTable Pointer to PCI IRQ Routing table.
@param RoutingTableEntries Number of entries in table.
@param LocalPirqTable $PIR table
@param PirqTableSize $PIR table size
@param LocalIrqPriorityTable List of interrupts in priority order to assign
@param IrqPriorityTableEntries Number of entries in 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
@param This Protocol instance pointer.
@param PciBus PCI bus number for this device.
@param PciDevice PCI device number for this device.
@param PciFunction PCI function number for this device.
@param Pirq Input is PIRQ reported by device, 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 Protocol instance pointer.
@param BbsDevicePath EFI Device Path from BootXXXX variable.
@param BbsTable Internal BBS table.
@param LoadOptionSize Size of LoadOption in size.
@param LoadOption LoadOption from BootXXXX variable
@param EfiToLegacy16BootTable 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
);
/**
@par Protocol Description:
Abstracts the platform portion of the traditional BIOS.
@param GetPlatformInfo
Gets binary data or other platform information.
@param GetPlatformHandle
Returns a buffer of all handles matching the requested subfunction.
@param SmmInit
Loads and initializes the traditional BIOS SMM handler.
@param PlatformHooks
Allows platform to perform any required actions after a LegacyBios operation.
@param GetRoutingTable
Gets $PIR table.
@param TranslatePirq
Translates the given PIRQ to the final value after traversing any PCI bridges.
@param PrepareToBoot
Final platform function before the system attempts to boot to a traditional OS.
**/
struct _EFI_LEGACY_BIOS_PLATFORM_PROTOCOL {
EFI_LEGACY_BIOS_PLATFORM_GET_PLATFORM_INFO GetPlatformInfo;
EFI_LEGACY_BIOS_PLATFORM_GET_PLATFORM_HANDLE GetPlatformHandle;
EFI_LEGACY_BIOS_PLATFORM_SMM_INIT SmmInit;
EFI_LEGACY_BIOS_PLATFORM_HOOKS PlatformHooks;
EFI_LEGACY_BIOS_PLATFORM_GET_ROUTING_TABLE GetRoutingTable;
EFI_LEGACY_BIOS_PLATFORM_TRANSLATE_PIRQ TranslatePirq;
EFI_LEGACY_BIOS_PLATFORM_PREPARE_TO_BOOT PrepareToBoot;
};
extern EFI_GUID gEfiLegacyBiosPlatformProtocolGuid;
#endif

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

@@ -0,0 +1,131 @@
/** @file
This protocol manages the legacy memory regions between 0xc0000 - 0xfffff
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: LegacyInterrupt.h
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.96
**/
#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 Protocol instance pointer.
@param NumberPirsq Number of PIRQs.
@retval EFI_SUCCESS Number of PIRQs returned.
**/
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 Protocol instance pointer.
@param Bus PCI Bus
@param Device PCI Device
@param Function PCI Function
@retval EFI_SUCCESS Bus/Device/Function returned
**/
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 Protocol instance pointer.
@param PirqNumber PIRQ register to read
@param PirqData Data read
@retval EFI_SUCCESS 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 Protocol instance pointer.
@param PirqNumber PIRQ register to read.
@param PirqData Data written.
@retval EFI_SUCCESS Table pointer returned
@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
);
/**
@par Protocol Description:
Abstracts the PIRQ programming from the generic EFI Compatibility Support Modules
@param GetNumberPirqs
Gets the number of PIRQs supported.
@param GetLocation
Gets the PCI bus, device, and function that associated with this protocol.
@param ReadPirq
Reads the indicated PIRQ register.
@param WritePirq
Writes to the indicated PIRQ register.
**/
struct _EFI_LEGACY_INTERRUPT_PROTOCOL {
EFI_LEGACY_INTERRUPT_GET_NUMBER_PIRQS GetNumberPirqs;
EFI_LEGACY_INTERRUPT_GET_LOCATION GetLocation;
EFI_LEGACY_INTERRUPT_READ_PIRQ ReadPirq;
EFI_LEGACY_INTERRUPT_WRITE_PIRQ WritePirq;
};
extern EFI_GUID gEfiLegacyInterruptProtocolGuid;
#endif

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

@@ -0,0 +1,140 @@
/** @file
This protocol manages the legacy memory regions between 0xc0000 - 0xfffff
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: LegacyRegion.h
@par Revision Reference:
This protocol is defined in Framework for EFI Compatibility Support Module spec
Version 0.96
**/
#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 Start of region to decode.
@param Length Size in bytes of the region.
@param On Decode/nondecode flag.
@retval EFI_SUCCESS 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 Start of region to lock.
@param Length 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 Start of region to lock.
@param Length 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 Start of region to lock.
@param Length 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
);
/**
@par Protocol Description:
Abstracts the hardware control of the physical address region 0xC0000-C0xFFFFF
for the traditional BIOS.
@param Decode
Specifies a region for the chipset to decode
@param Lock
Makes the specified OpROM region read only or locked.
@param BootLock
Sets a region to read only and ensures tat flash is locked from
inadvertent modification.
@param Unlock
Makes the specified OpROM region read-write or unlocked.
**/
struct _EFI_LEGACY_REGION_PROTOCOL {
EFI_LEGACY_REGION_DECODE Decode;
EFI_LEGACY_REGION_LOCK Lock;
EFI_LEGACY_REGION_BOOT_LOCK BootLock;
EFI_LEGACY_REGION_UNLOCK UnLock;
};
extern EFI_GUID gEfiLegacyRegionProtocolGuid;
#endif

363
IntelFrameworkPkg/Include/Protocol/PciHostBridgeResourceAllocation.h Normal file
View File

@@ -0,0 +1,363 @@
/** @file
This file declares Pci Host Bridge Resource Allocation Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: PciHostBridgeResourceAllocation.h
@par Revision Reference:
This protocol is defined in Framework of EFI Pci Host Bridge Resource Allocation Protocol Spec
Version 0.9
**/
#ifndef _PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_H_
#define _PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_H_
#define EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GUID \
{ 0xCF8034BE, 0x6768, 0x4d8b, {0xB7,0x39,0x7C,0xCE,0x68,0x3A,0x9F,0xBE }}
typedef struct _EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL;
//
// EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ATTRIBUTES
//
// If this bit is set, then the PCI Root Bridge does not
// support separate windows for Non-prefetchable and Prefetchable
// memory. A PCI bus driver needs to include requests for Prefetchable
// memory in the Non-prefetchable memory pool.
//
#define EFI_PCI_HOST_BRIDGE_COMBINE_MEM_PMEM 1
//
// If this bit is set, then the PCI Root Bridge supports
// 64 bit memory windows. If this bit is not set,
// the PCI bus driver needs to include requests for 64 bit
// memory address in the corresponding 32 bit memory pool.
//
#define EFI_PCI_HOST_BRIDGE_MEM64_DECODE 2
//
// EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE
//
typedef enum {
EfiPciHostBridgeBeginEnumeration,
EfiPciHostBridgeBeginBusAllocation,
EfiPciHostBridgeEndBusAllocation,
EfiPciHostBridgeBeginResourceAllocation,
EfiPciHostBridgeAllocateResources,
EfiPciHostBridgeSetResources,
EfiPciHostBridgeFreeResources,
EfiPciHostBridgeEndResourceAllocation
} EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE;
//
// EfiPciHostBridgeBeginEnumeration
// Reset the host bridge PCI apertures and internal data structures.
// PCI enumerator should issue this notification before starting fresh
// enumeration process. Enumeration cannot be restarted after sending
// any other notification such as EfiPciHostBridgeBeginBusAllocation.
//
// EfiPciHostBridgeBeginBusAllocation
// The bus allocation phase is about to begin. No specific action
// is required here. This notification can be used to perform any
// chipset specific programming.
//
// EfiPciHostBridgeEndBusAllocation
// The bus allocation and bus programming phase is complete. No specific
// action is required here. This notification can be used to perform any
// chipset specific programming.
//
// EfiPciHostBridgeBeginResourceAllocation
// The resource allocation phase is about to begin.No specific action is
// required here. This notification can be used to perform any chipset specific programming.
//
// EfiPciHostBridgeAllocateResources
// Allocate resources per previously submitted requests for all the PCI Root
// Bridges. These resource settings are returned on the next call to
// GetProposedResources().
//
// EfiPciHostBridgeSetResources
// Program the Host Bridge hardware to decode previously allocated resources
// (proposed resources) for all the PCI Root Bridges.
//
// EfiPciHostBridgeFreeResources
// De-allocate previously allocated resources previously for all the PCI
// Root Bridges and reset the I/O and memory apertures to initial state.
//
// EfiPciHostBridgeEndResourceAllocation
// The resource allocation phase is completed. No specific action is required
// here. This notification can be used to perform any chipset specific programming.
//
// EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE
//
typedef enum {
EfiPciBeforeChildBusEnumeration,
EfiPciBeforeResourceCollection
} EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE;
//
// EfiPciBeforeChildBusEnumeration
// This notification is only applicable to PCI-PCI bridges and
// indicates that the PCI enumerator is about to begin enumerating
// the bus behind the PCI-PCI Bridge. This notification is sent after
// the primary bus number, the secondary bus number and the subordinate
// bus number registers in the PCI-PCI Bridge are programmed to valid
// (not necessary final) values
//
// EfiPciBeforeResourceCollection
// This notification is sent before the PCI enumerator probes BAR registers
// for every valid PCI function.
//
/**
Enter a certain phase of the PCI enumeration process
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL instance
@param Phase The phase during enumeration
@retval EFI_SUCCESS Success
@retval EFI_OUT_OF_RESOURCES If SubmitResources ( ) could not allocate resources
@retval EFI_NOT_READY This phase cannot be entered at this time
@retval EFI_DEVICE_ERROR SetResources failed due to HW error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_NOTIFY_PHASE) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE Phase
);
/**
Return the device handle of the next PCI root bridge that is associated with
this Host Bridge
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle Returns the device handle of the next PCI Root Bridge.
On input, it holds the RootBridgeHandle returned by the most
recent call to GetNextRootBridge().The handle for the first
PCI Root Bridge is returned if RootBridgeHandle is NULL on input
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_NEXT_ROOT_BRIDGE) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN OUT EFI_HANDLE *RootBridgeHandle
);
/**
Returns the attributes of a PCI Root Bridge.
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle The device handle of the PCI Root Bridge
that the caller is interested in
@param Attribute The pointer to attributes of the PCI Root Bridge
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
@retval EFI_INVALID_PARAMETER Attributes is NULL
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_ATTRIBUTES) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_HANDLE RootBridgeHandle,
OUT UINT64 *Attributes
);
/**
This is the request from the PCI enumerator to set up
the specified PCI Root Bridge for bus enumeration process.
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle The PCI Root Bridge to be set up
@param Configuration Pointer to the pointer to the PCI bus resource descriptor
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
@retval EFI_DEVICE_ERROR Request failed due to hardware error
@retval EFI_OUT_OF_RESOURCES Request failed due to lack of resources
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_START_BUS_ENUMERATION) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_HANDLE RootBridgeHandle,
OUT VOID **Configuration
);
/**
This function programs the PCI Root Bridge hardware so that
it decodes the specified PCI bus range
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle The PCI Root Bridge whose bus range is to be programmed
@param Configuration The pointer to the PCI bus resource descriptor
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
@retval EFI_INVALID_PARAMETER Configuration is NULL
@retval EFI_INVALID_PARAMETER Configuration does not point to a valid ACPI resource descriptor
@retval EFI_INVALID_PARAMETER Configuration contains one or more memory or IO ACPI resource descriptor
@retval EFI_INVALID_PARAMETER Address Range Minimum or Address Range Length fields in Configuration
are invalid for this Root Bridge.
@retval EFI_INVALID_PARAMETER Configuration contains one or more invalid ACPI resource descriptor
@retval EFI_DEVICE_ERROR Request failed due to hardware error
@retval EFI_OUT_OF_RESOURCES Request failed due to lack of resources
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SET_BUS_NUMBERS) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_HANDLE RootBridgeHandle,
IN VOID *Configuration
);
/**
Submits the I/O and memory resource requirements for the specified PCI Root Bridge
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle The PCI Root Bridge whose I/O and memory resource requirements
are being submitted
@param Configuration The pointer to the PCI I/O and PCI memory resource descriptor
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
@retval EFI_INVALID_PARAMETER Configuration is NULL
@retval EFI_INVALID_PARAMETER Configuration does not point to a valid ACPI resource descriptor
@retval EFI_INVALID_PARAMETER Configuration includes a resource descriptor of unsupported type
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SUBMIT_RESOURCES) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_HANDLE RootBridgeHandle,
IN VOID *Configuration
);
/**
This function returns the proposed resource settings for the specified
PCI Root Bridge
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle The PCI Root Bridge handle
@param Configuration The pointer to the pointer to the PCI I/O
and memory resource descriptor
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
@retval EFI_DEVICE_ERROR Request failed due to hardware error
@retval EFI_OUT_OF_RESOURCES Request failed due to lack of resources
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_PROPOSED_RESOURCES) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_HANDLE RootBridgeHandle,
OUT VOID **Configuration
);
/**
This function is called for all the PCI controllers that the PCI
bus driver finds. Can be used to Preprogram the controller.
@param This The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
@param RootBridgeHandle The PCI Root Bridge handle
@param PciBusAddress Address of the controller on the PCI bus
@param Phase The Phase during resource allocation
@retval EFI_SUCCESS Success
@retval EFI_INVALID_PARAMETER RootBridgeHandle is invalid
@retval EFI_DEVICE_ERROR Device pre-initialization failed due to hardware error.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_PREPROCESS_CONTROLLER) (
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL *This,
IN EFI_HANDLE RootBridgeHandle,
IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS PciAddress,
IN EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE Phase
);
/**
@par Protocol Description:
Provides the basic interfaces to abstract a PCI host bridge resource allocation.
@param NotifyPhase
The notification from the PCI bus enumerator that it is about to enter
a certain phase during the enumeration process.
@param GetNextRootBridge
Retrieves the device handle for the next PCI root bridge that is produced by the
host bridge to which this instance of the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL is attached.
@param GetAllocAttributes
Retrieves the allocation-related attributes of a PCI root bridge.
@param StartBusEnumeration
Sets up a PCI root bridge for bus enumeration.
@param SetBusNumbers
Sets up the PCI root bridge so that it decodes a specific range of bus numbers.
@param SubmitResources
Submits the resource requirements for the specified PCI root bridge.
@param GetProposedResources
Returns the proposed resource assignment for the specified PCI root bridges.
@param PreprocessController
Provides hooks from the PCI bus driver to every PCI controller
(device/function) at various stages of the PCI enumeration process that
allow the host bridge driver to preinitialize individual PCI controllers
before enumeration.
**/
struct _EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL {
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_NOTIFY_PHASE NotifyPhase;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_NEXT_ROOT_BRIDGE GetNextRootBridge;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_ATTRIBUTES GetAllocAttributes;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_START_BUS_ENUMERATION StartBusEnumeration;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SET_BUS_NUMBERS SetBusNumbers;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SUBMIT_RESOURCES SubmitResources;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_PROPOSED_RESOURCES GetProposedResources;
EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_PREPROCESS_CONTROLLER PreprocessController;
};
extern EFI_GUID gEfiPciHostBridgeResourceAllocationProtocolGuid;
#endif

165
IntelFrameworkPkg/Include/Protocol/PciHotPlugInit.h Normal file
View File

@@ -0,0 +1,165 @@
/** @file
This file declares EFI PCI Hot Plug Init Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: PciHotPlugInit.h
@par Revision Reference:
This protocol is defined in Framework of EFI Hot Plug Pci Initialization Protocol Spec
Version 0.9
**/
#ifndef _EFI_PCI_HOT_PLUG_INIT_H_
#define _EFI_PCI_HOT_PLUG_INIT_H_
//
// Global ID for the PCI Hot Plug Protocol
//
#define EFI_PCI_HOT_PLUG_INIT_PROTOCOL_GUID \
{ 0xaa0e8bc1, 0xdabc, 0x46b0, {0xa8, 0x44, 0x37, 0xb8, 0x16, 0x9b, 0x2b, 0xea } }
typedef struct _EFI_PCI_HOT_PLUG_INIT_PROTOCOL EFI_PCI_HOT_PLUG_INIT_PROTOCOL;
#define EFI_HPC_STATE_INITIALIZED 0x01
#define EFI_HPC_STATE_ENABLED 0x02
typedef UINT16 EFI_HPC_STATE;
typedef struct{
EFI_DEVICE_PATH_PROTOCOL *HpcDevicePath;
EFI_DEVICE_PATH_PROTOCOL *HpbDevicePath;
} EFI_HPC_LOCATION;
typedef enum{
EfiPaddingPciBus,
EfiPaddingPciRootBridge
} EFI_HPC_PADDING_ATTRIBUTES;
/**
Returns a list of root Hot Plug Controllers (HPCs) that require initialization
during the boot process.
@param This Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL instance.
@param HpcCount The number of root HPCs that were returned.
@param HpcList The list of root HPCs. HpcCount defines the number of
elements in this list.
@retval EFI_SUCCESS HpcList was returned.
@retval EFI_OUT_OF_RESOURCES HpcList was not returned due to insufficient resources.
@retval EFI_INVALID_PARAMETER HpcCount is NULL or HpcList is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_GET_ROOT_HPC_LIST) (
IN EFI_PCI_HOT_PLUG_INIT_PROTOCOL *This,
OUT UINTN *HpcCount,
OUT EFI_HPC_LOCATION **HpcList
);
/**
Initializes one root Hot Plug Controller (HPC). This process may causes
initialization of its subordinate buses.
@param This Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL instance.
@param HpcDevicePath The device path to the HPC that is being initialized.
@param HpcPciAddress The address of the HPC function on the PCI bus.
@param Event The event that should be signaled when the HPC initialization
is complete.
@param HpcState The state of the HPC hardware.
@retval EFI_SUCCESS If Event is NULL, the specific HPC was successfully
initialized. If Event is not NULL, Event will be signaled at a later time
when initialization is complete.
@retval EFI_UNSUPPORTED This instance of EFI_PCI_HOT_PLUG_INIT_PROTOCOL
does not support the specified HPC.
@retval EFI_OUT_OF_RESOURCES Initialization failed due to insufficient
resources.
@retval EFI_INVALID_PARAMETER HpcState is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_INITIALIZE_ROOT_HPC) (
IN EFI_PCI_HOT_PLUG_INIT_PROTOCOL *This,
IN EFI_DEVICE_PATH_PROTOCOL *HpcDevicePath,
IN UINT64 HpcPciAddress,
IN EFI_EVENT Event, OPTIONAL
OUT EFI_HPC_STATE *HpcState
);
/**
Returns the resource padding that is required by the PCI bus that is controlled
by the specified Hot Plug Controller (HPC).
@param This Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL instance.
@param HpcDevicePath The device path to the HPC.
@param HpcPciAddress The address of the HPC function on the PCI bus.
@param HpcState The state of the HPC hardware.
@param Padding The amount of resource padding that is required by the
PCI bus under the control of the specified HPC.
@param Attributes Describes how padding is accounted for. The padding
is returned in the form of ACPI 2.0 resource descriptors.
@retval EFI_SUCCESS The resource padding was successfully returned.
@retval EFI_UNSUPPORTED This instance of the EFI_PCI_HOT_PLUG_INIT_PROTOCOL
does not support the specified HPC.
@retval EFI_NOT_READY This function was called before HPC initialization is complete.
@retval EFI_INVALID_PARAMETER HpcState or Padding or Attributes is NULL.
@retval EFI_OUT_OF_RESOURCES ACPI 2.0 resource descriptors for Padding
cannot be allocated due to insufficient resources.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_GET_PCI_HOT_PLUG_PADDING) (
IN EFI_PCI_HOT_PLUG_INIT_PROTOCOL *This,
IN EFI_DEVICE_PATH_PROTOCOL *HpcDevicePath,
IN UINT64 HpcPciAddress,
OUT EFI_HPC_STATE *HpcState,
OUT VOID **Padding,
OUT EFI_HPC_PADDING_ATTRIBUTES *Attributes
);
//
// Prototypes for the PCI Hot Plug Init Protocol
//
/**
@par Protocol Description:
This protocol provides the necessary functionality to initialize the
Hot Plug Controllers (HPCs) and the buses that they control. This protocol
also provides information regarding resource padding.
@param GetRootHpcList
Returns a list of root HPCs and the buses that they control.
@param InitializeRootHpc
Initializes the specified root HPC.
@param GetResourcePadding
Returns the resource padding that is required by the HPC.
**/
struct _EFI_PCI_HOT_PLUG_INIT_PROTOCOL {
EFI_GET_ROOT_HPC_LIST GetRootHpcList;
EFI_INITIALIZE_ROOT_HPC InitializeRootHpc;
EFI_GET_PCI_HOT_PLUG_PADDING GetResourcePadding;
};
extern EFI_GUID gEfiPciHotPlugInitProtocolGuid;
#endif

206
IntelFrameworkPkg/Include/Protocol/PciPlatform.h Normal file
View File

@@ -0,0 +1,206 @@
/** @file
This file declares PlatfromOpRom protocols.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: PciPlatform.h
@par Revision Reference:
This protocol is defined in PCI Platform Support Specification
Version 0.9
**/
#ifndef _PCI_PLATFORM_H_
#define _PCI_PLATFORM_H_
//
// Protocol for GUID.
//
#define EFI_PCI_PLATFORM_PROTOCOL_GUID \
{ 0x7d75280, 0x27d4, 0x4d69, {0x90, 0xd0, 0x56, 0x43, 0xe2, 0x38, 0xb3, 0x41} }
typedef struct _EFI_PCI_PLATFORM_PROTOCOL EFI_PCI_PLATFORM_PROTOCOL;
typedef UINT32 EFI_PCI_PLATFORM_POLICY;
#define EFI_RESERVE_NONE_IO_ALIAS 0x0000
#define EFI_RESERVE_ISA_IO_ALIAS 0x0001
#define EFI_RESERVE_ISA_IO_NO_ALIAS 0x0002
#define EFI_RESERVE_VGA_IO_ALIAS 0x0004
#define EFI_RESERVE_VGA_IO_NO_ALIAS 0x0008
typedef enum {
ChipsetEntry,
ChipsetExit,
MaximumChipsetPhase
} EFI_PCI_CHIPSET_EXECUTION_PHASE;
/**
The PlatformNotify() function can be used to notify the platform driver so that
it can perform platform-specific actions. No specific actions are required.
Eight notification points are defined at this time. More synchronization points
may be added as required in the future. The PCI bus driver calls the platform driver
twice for every Phase-once before the PCI Host Bridge Resource Allocation Protocol
driver is notified, and once after the PCI Host Bridge Resource Allocation Protocol
driver has been notified.
This member function may not perform any error checking on the input parameters. It
also does not return any error codes. If this member function detects any error condition,
it needs to handle those errors on its own because there is no way to surface any
errors to the caller.
@param This Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
@param HostBridge The handle of the host bridge controller.
@param Phase The phase of the PCI bus enumeration.
@param ChipsetPhase Defines the execution phase of the PCI chipset driver.
@retval EFI_SUCCESS The function completed successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_PLATFORM_PHASE_NOTIFY) (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
IN EFI_HANDLE HostBridge,
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE Phase,
IN EFI_PCI_CHIPSET_EXECUTION_PHASE ChipsetPhase
)
;
/**
The PlatformPrepController() function can be used to notify the platform driver so that
it can perform platform-specific actions. No specific actions are required.
Several notification points are defined at this time. More synchronization points may be
added as required in the future. The PCI bus driver calls the platform driver twice for
every PCI controller-once before the PCI Host Bridge Resource Allocation Protocol driver
is notified, and once after the PCI Host Bridge Resource Allocation Protocol driver has
been notified.
This member function may not perform any error checking on the input parameters. It also
does not return any error codes. If this member function detects any error condition, it
needs to handle those errors on its own because there is no way to surface any errors to
the caller.
@param This Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
@param HostBridge The associated PCI host bridge handle.
@param RootBridge The associated PCI root bridge handle.
@param PciAddress The address of the PCI device on the PCI bus.
@param Phase The phase of the PCI controller enumeration.
@param ChipsetPhase Defines the execution phase of the PCI chipset driver.
@retval EFI_SUCCESS The function completed successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_PLATFORM_PREPROCESS_CONTROLLER) (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
IN EFI_HANDLE HostBridge,
IN EFI_HANDLE RootBridge,
IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS PciAddress,
IN EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE Phase,
IN EFI_PCI_CHIPSET_EXECUTION_PHASE ChipsetPhase
)
;
/**
The GetPlatformPolicy() function retrieves the platform policy regarding PCI
enumeration. The PCI bus driver and the PCI Host Bridge Resource Allocation Protocol
driver can call this member function to retrieve the policy.
@param This Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
@param PciPolicy The platform policy with respect to VGA and ISA aliasing.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER PciPolicy is NULL.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_PLATFORM_GET_PLATFORM_POLICY) (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
OUT EFI_PCI_PLATFORM_POLICY *PciPolicy
)
;
/**
The GetPciRom() function gets the PCI device's option ROM from a platform-specific location.
The option ROM will be loaded into memory. This member function is used to return an image
that is packaged as a PCI 2.2 option ROM. The image may contain both legacy and EFI option
ROMs. See the EFI 1.10 Specification for details. This member function can be used to return
option ROM images for embedded controllers. Option ROMs for embedded controllers are typically
stored in platform-specific storage, and this member function can retrieve it from that storage
and return it to the PCI bus driver. The PCI bus driver will call this member function before
scanning the ROM that is attached to any controller, which allows a platform to specify a ROM
image that is different from the ROM image on a PCI card.
@param This Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
@param PciHandle The handle of the PCI device.
@param RomImage If the call succeeds, the pointer to the pointer to the option ROM image.
Otherwise, this field is undefined. The memory for RomImage is allocated
by EFI_PCI_PLATFORM_PROTOCOL.GetPciRom() using the EFI Boot Service AllocatePool().
It is the caller's responsibility to free the memory using the EFI Boot Service
FreePool(), when the caller is done with the option ROM.
@param RomSize If the call succeeds, a pointer to the size of the option ROM size. Otherwise,
this field is undefined.
@retval EFI_SUCCESS The option ROM was available for this device and loaded into memory.
@retval EFI_NOT_FOUND No option ROM was available for this device.
@retval EFI_OUT_OF_RESOURCES No memory was available to load the option ROM.
@retval EFI_DEVICE_ERROR An error occurred in getting the option ROM.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_PLATFORM_GET_PCI_ROM) (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
IN EFI_HANDLE PciHandle,
OUT VOID **RomImage,
OUT UINTN *RomSize
)
;
/**
@par Protocol Description:
This protocol provides the interface between the PCI bus driver/PCI Host
Bridge Resource Allocation driver and a platform-specific driver to describe
the unique features of a platform.
@param PlatformNotify
The notification from the PCI bus enumerator to the platform that it is
about to enter a certain phase during the enumeration process.
@param PlatformPrepController
The notification from the PCI bus enumerator to the platform for each PCI
controller at several predefined points during PCI controller initialization.
@param GetPlatformPolicy
Retrieves the platform policy regarding enumeration.
@param GetPciRom
Gets the PCI device's option ROM from a platform-specific location.
**/
struct _EFI_PCI_PLATFORM_PROTOCOL {
EFI_PCI_PLATFORM_PHASE_NOTIFY PhaseNotify;
EFI_PCI_PLATFORM_PREPROCESS_CONTROLLER PlatformPrepController;
EFI_PCI_PLATFORM_GET_PLATFORM_POLICY GetPlatformPolicy;
EFI_PCI_PLATFORM_GET_PCI_ROM GetPciRom;
};
extern EFI_GUID gEfiPciPlatformProtocolGuid;
#endif

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

@@ -0,0 +1,160 @@
/** @file
This file declares Section Extraction protocols.
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) 2007, Intel Corporation
All rights reserved. This program and the materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SectionExtraction.h
@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 Size in bytes of the section stream.
@param SectionStream 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 Pointer to an EFI_SECTION_TYPE.
@param SectionDefinitionGuid 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 Pointer to a caller-allocated UINTN.
@param AuthenticationStatus 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 in
the 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_BUFFER_TOO_SMALL The size of the input buffer is insufficient to
contain the requested section.
**/
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
//
/**
@par Protocol Description:
The Section Extraction Protocol provides a simple method of extracting
sections from arbitrarily complex files.
@param OpenSectionStream
Takes a bounded stream of sections and returns a section stream handle.
@param GetSection
Given a section stream handle, retrieves the requested section and
meta-data from the section stream.
@param CloseSectionStream
Given a section stream handle, closes the section stream.
**/
struct _EFI_SECTION_EXTRACTION_PROTOCOL {
EFI_OPEN_SECTION_STREAM OpenSectionStream;
EFI_GET_SECTION GetSection;
EFI_CLOSE_SECTION_STREAM CloseSectionStream;
};
extern EFI_GUID gEfiSectionExtractionProtocolGuid;
#endif

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

@@ -0,0 +1,159 @@
/** @file
This file declares SMM SMRAM Access abstraction protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmAccess.h
@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 <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 constant and types
//
// *******************************************************
// EFI_SMRAM_STATE
// *******************************************************
//
#define EFI_SMRAM_OPEN 0x00000001
#define EFI_SMRAM_CLOSED 0x00000002
#define EFI_SMRAM_LOCKED 0x00000004
#define EFI_CACHEABLE 0x00000008
#define EFI_ALLOCATED 0x00000010
//
// 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 open
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 open
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
);
/**
@par Protocol Description:
This protocol is used to control the visibility of the SMRAM on the platform.
@param Open
Opens the SMRAM.
@param Close
Closes the SMRAM.
@param Lock
Locks the SMRAM.
@param GetCapabilities
Gets information on possible SMRAM regions.
@param LockState
Indicates the current state of the SMRAM. Set to TRUE if any region is locked.
@param OpenState
Indicates the current state of the SMRAM. Set to TRUE if any region is open.
**/
struct _EFI_SMM_ACCESS_PROTOCOL {
EFI_SMM_OPEN Open;
EFI_SMM_CLOSE Close;
EFI_SMM_LOCK Lock;
EFI_SMM_CAPABILITIES GetCapabilities;
BOOLEAN LockState;
BOOLEAN OpenState;
};
extern EFI_GUID gEfiSmmAccessProtocolGuid;
#endif

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

@@ -0,0 +1,308 @@
/** @file
This file declares SMM Base abstraction protocol.
This is the base level of compatiblity for SMM drivers.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmBase.h
@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_
#define EFI_SMM_BASE_PROTOCOL_GUID \
{ \
0x1390954D, 0xda95, 0x4227, {0x93, 0x28, 0x72, 0x82, 0xc2, 0x17, 0xda, 0xa8 } \
}
typedef struct _EFI_SMM_BASE_PROTOCOL EFI_SMM_BASE_PROTOCOL;
//
// SMM Handler Definition
//
#define EFI_HANDLER_SUCCESS 0x0000
#define EFI_HANDLER_CRITICAL_EXIT 0x0001
#define EFI_HANDLER_SOURCE_QUIESCED 0x0002
#define EFI_HANDLER_SOURCE_PENDING 0x0003
/**
Entry Point to Callback service
@param SmmImageHandle A handle allocated by the SMM infrastructure code
to uniquely designate a specific DXE SMM driver.
@param 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, physically mapped, and be a physical address.
@param 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 This Protocol instance pointer.
@param FilePath Location of the image to be installed as the handler.
@param SourceBuffer Optional source buffer in case of the image file
being in memory.
@param SourceSize Size of the source image file, if in memory.
@param ImageHandle Pointer to the handle that reflects the driver
loaded into SMM.
@param LegacyIA32Binary The binary image to load is legacy 16 bit code.
@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 In runtime.
@retval EFI_INVALID_PARAMETER The handlers was 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
)
;
/**
Remove a given driver SMRAM. This is the equivalent of performing
the UnloadImage System Management Mode.
@param This Protocol instance pointer.
@param ImageHandle Pointer to the handle that reflects the driver
loaded into SMM.
@retval EFI_SUCCESS The operation was successful
@retval EFI_INVALID_PARAMETER The handler did not exist
@retval EFI_UNSUPPORTED 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 services to send/received messages from a registered
EFI service. The BASE protocol driver is responsible for doing
any of the copies such that the data lives in boot-service accessible RAM.
@param This Protocol instance pointer.
@param ImageHandle Pointer to the handle that reflects the driver
loaded into SMM.
@param CommunicationBuffer Pointer to the buffer to convey into SMRAM.
@param SourceSize Size of the contents of buffer..
@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 the Boot Service COMMUNICATE.
@param This Protocol instance pointer.
@param CallbackAddress Address of the callback service
@param MakeFirst If present, will stipulate that the handler is posted
to be the first module executed in the dispatch table.
@param MakeLast If present, will stipulate that the handler is posted
to be last executed in the dispatch table.
@param FloatingPointSave This is an optional parameter which informs the
EFI_SMM_ACCESS_PROTOCOL Driver core if it needs to save
the floating point register state. If any of the handlers
require this, then the state will be saved for all of the handlers.
@retval EFI_SUCCESS The operation was successful
@retval EFI_OUT_OF_RESOURCES Not enough space in the dispatch queue
@retval EFI_UNSUPPORTED In runtime.
@retval EFI_UNSUPPORTED 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 This Protocol instance pointer.
@param PoolType The type of pool to allocate.
The only supported type is EfiRuntimeServicesData;
the interface will internally map this runtime request to SMRAM.
@param Size The number of bytes to allocate from the pool.
@param 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_INVALID_PARAMETER PoolType was invalid.
@retval EFI_UNSUPPORTED 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 This Protocol instance pointer.
@param Buffer Pointer to the buffer allocation.
@retval EFI_SUCCESS The memory was returned to the system.
@retval EFI_INVALID_PARAMETER Buffer was invalid.
@retval EFI_UNSUPPORTED 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 This Protocol instance pointer.
@param 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
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_INSIDE_OUT) (
IN EFI_SMM_BASE_PROTOCOL *This,
OUT BOOLEAN *InSmm
)
;
/**
The GetSmstLocation() function returns the locatin of the System Management
Service Table. The use of the API is such that a driver can discover the
location of the SMST in its entry point and then cache it in some driver
global variable so that the SMST can be invoked in subsequent callbacks.
@param This Protocol instance pointer.
@param Smst 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
)
;
/**
@par Protocol Description:
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.
@param Register
Registers a handler to run in System Management RAM (SMRAM).
@param UnRegister
Removes a handler from execution in SMRAM.
@param Communicate
Sends/receives a message for a registered handler.
@param RegisterCallback
Registers a callback from the constructor.
@param InSmm
Detects whether the caller is inside or outside of SMM. SName
@param SmmAllocatePool
Allocates SMRAM.
@param SmmFreePool
Deallocates SMRAM.
@param GetSmstLocation
Retrieves the location of the System Management System Table (SMST).
**/
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

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

@@ -0,0 +1,128 @@
/** @file
This file declares SMM Control abstraction protocol.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmControl.h
@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 {
UINT8 SmiTriggerRegister;
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 Optional sized data to pass into the protocol activation.
@param ArgumentBufferSize Optional size of the data.
@param Periodic Optional mechanism to engender a periodic stream.
@param ActivationInterval Optional parameter to repeat at this period one
time or, if the Periodic Boolean is set, periodically.
@retval EFI_SUCCESS The SMI/PMI has been engendered.
@retval EFI_DEVICE_ERROR The timing is unsupported.
@retval EFI_INVALID_PARAMETER The activation period is unsupported.
@retval EFI_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
@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 Pointer to the SMI register description structure
@retval EFI_SUCCESS The register structure has been returned.
**/
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 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.
**/
struct _EFI_SMM_CONTROL_PROTOCOL {
EFI_SMM_ACTIVATE Trigger;
EFI_SMM_DEACTIVATE Clear;
EFI_SMM_GET_REGISTER_INFO GetRegisterInfo;
UINTN MinimumTriggerPeriod;
};
extern EFI_GUID gEfiSmmControlProtocolGuid;
#endif

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

@@ -0,0 +1,149 @@
/** @file
This file declares Smm Gpi Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmGpiDispatch.h
@par Revision Reference:
This Protocol is defined in Framework of EFI SMM Core Interface Spec
Version 0.9.
**/
#ifndef _EFI_SMM_GPI_DISPATCH_H_
#define _EFI_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 a
// a SMI. Bit 0 corresponds to logical GPI[0], 1 corresponds to logical GPI[1], etc.
//
// 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 Handle of this dispatch function.
@param DispatchContext 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_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 Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function the GPI(s) for which the dispatch function
should be invoked.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_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
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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.
@retval other TBD
**/
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
//
/**
@par Protocol Description:
Provides the parent dispatch service for the General Purpose Input
(GPI) SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
@param NumSupportedGpis
Denotes the maximum value of inputs that can have handlers attached.
**/
struct _EFI_SMM_GPI_DISPATCH_PROTOCOL {
EFI_SMM_GPI_REGISTER Register;
EFI_SMM_GPI_UNREGISTER UnRegister;
UINTN NumSupportedGpis;
};
extern EFI_GUID gEfiSmmGpiDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,193 @@
/** @file
This file declares EFI Smm ICH [N] Specific Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmIchnDispatch.h
@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,
//
// 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 ICH n specific SMI handler.
@param DispatchHandle Handle of this dispatch function.
@param DispatchContext Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Nothing
**/
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 Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext 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 ICHN SMI source for which the dispatch
function should be invoked.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_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 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 Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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.
@retval other TBD
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ICHN_UNREGISTER) (
IN EFI_SMM_ICHN_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Ich n specific SMI Dispatch Protocol
//
/**
@par Protocol Description:
Provides the parent dispatch service for a given SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
**/
struct _EFI_SMM_ICHN_DISPATCH_PROTOCOL {
EFI_SMM_ICHN_REGISTER Register;
EFI_SMM_ICHN_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmIchnDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,194 @@
/** @file
This file declares EFI Smm Periodic Timer Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmPeriodicTimerDispatch.h
@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
//
//
// Period is the minimum period of time in 100 nanosecond units that child gets called.
// The child will be called back after a time greater than the time Period.
//
// SmiTickInterval is 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.
// Example: A chipset supports periodic SMIs on every 64ms or 2 seconds.
// A child wishes schedule a period SMI to fire on a period of 3 seconds, there
// are several ways to approach the problem:
// 1. The child may accept a 4 second periodic rate, in which case it registers with
// Period = 40000
// SmiTickInterval = 20000
// The resulting SMI will occur every 2 seconds with the child called back on
// every 2nd SMI.
// NOTE: the same result would occur if the child set SmiTickInterval = 0.
// 2. The child may choose the finer granularity SMI (64ms):
// Period = 30000
// SmiTickInterval = 640
// The resulting SMI will occur every 64ms with the child called back on
// every 47th SMI.
// NOTE: the child driver should be aware that this will result in more
// SMIs occuring during system runtime which can negatively impact system
// performance.
//
// ElapsedTime is the actual time in 100 nanosecond units elapsed since last called, a
// value of 0 indicates an unknown amount of time.
//
typedef struct {
UINT64 Period;
UINT64 SmiTickInterval;
UINT64 ElapsedTime;
} EFI_SMM_PERIODIC_TIMER_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Periodic Timer SMI handler.
@param DispatchHandle Handle of this dispatch function.
@param DispatchContext Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Nothing
**/
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 Protocol instance pointer.
@param SmiTickInterval 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 Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function the period at which the dispatch function
should be invoked.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_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
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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_PERIODIC_TIMER_UNREGISTER) (
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Periodic Timer Dispatch Protocol
//
/**
@par Protocol Description:
Provides the parent dispatch service for the periodical timer SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
@param GetNextShorterInterval
Returns the next SMI tick period that is supported by the chipset.
**/
struct _EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL {
EFI_SMM_PERIODIC_TIMER_REGISTER Register;
EFI_SMM_PERIODIC_TIMER_UNREGISTER UnRegister;
EFI_SMM_PERIODIC_TIMER_INTERVAL GetNextShorterInterval;
};
extern EFI_GUID gEfiSmmPeriodicTimerDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,147 @@
/** @file
This file declares EFI Smm Power Button Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmPowerButtonDispatch.h
@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 DispatchHandle Handle of this dispatch function.
@param DispatchContext Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Nothing
**/
typedef
VOID
(EFIAPI *EFI_SMM_POWER_BUTTON_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext 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 Power Button SMI phase for which the dispatch
function should be invoked.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_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
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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.
@retval other TBD
**/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_POWER_BUTTON_UNREGISTER) (
IN EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM Power Button SMI Dispatch Protocol
//
/**
@par Protocol Description:
Provides the parent dispatch service for the SMM power button SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
**/
struct _EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL {
EFI_SMM_POWER_BUTTON_REGISTER Register;
EFI_SMM_POWER_BUTTON_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmPowerButtonDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,148 @@
/** @file
This file declares EFI Smm Standby Button Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmStandbyButtonDispatch.h
@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_
//
// 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
//
//
// Standby Button. Example, Use for changing LEDs before ACPI OS is on.
// - DXE/BDS Phase
// - OS Install Phase
//
typedef enum {
EfiStandbyButtonEntry,
EfiStandbyButtonExit,
EfiStandbyButtonMax
} EFI_STANDBY_BUTTON_PHASE;
typedef struct {
EFI_STANDBY_BUTTON_PHASE Phase;
} EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a Standby Button SMI handler.
@param DispatchHandle Handle of this dispatch function.
@param DispatchContext Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
@return Nothing
**/
typedef
VOID
(EFIAPI *EFI_SMM_STANDBY_BUTTON_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT *DispatchContext
);
/**
Register a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext 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 Standby Button SMI phase for which the dispatch
function should be invoked.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_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 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 Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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.
@retval other TBD
**/
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
//
/**
@par Protocol Description:
Provides the parent dispatch service for the standby button SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
**/
struct _EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL {
EFI_SMM_STANDBY_BUTTON_REGISTER Register;
EFI_SMM_STANDBY_BUTTON_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmStandbyButtonDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,149 @@
/** @file
This file declares EFI Smm Software Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmSwDispatch.h
@par Revision Reference:
This Protocol is defined in Framework of 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 Handle of this dispatch function.
@param DispatchContext 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.
Nothing
**/
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 Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function which Software SMI input value the
dispatch function should be invoked for.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The SW 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 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 Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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.
@retval other TBD
**/
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
//
/**
@par Protocol Description:
Provides the parent dispatch service for a given SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
@param MaximumSwiValue
A read-only field that describes the maximum value that can be used
in the EFI_SMM_SW_DISPATCH_PROTOCOL.Register() service.
**/
struct _EFI_SMM_SW_DISPATCH_PROTOCOL {
EFI_SMM_SW_REGISTER Register;
EFI_SMM_SW_UNREGISTER UnRegister;
UINTN MaximumSwiValue;
};
extern EFI_GUID gEfiSmmSwDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,160 @@
/** @file
This file declares EFI Smm Sx Smi Child Protocol
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmSxDispatch.h
@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_
//
// 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;
//
// Related Definitions
//
typedef enum {
SxS0,
SxS1,
SxS2,
SxS3,
SxS4,
SxS5,
EfiMaximumSleepType
} EFI_SLEEP_TYPE;
typedef enum {
SxEntry,
SxExit,
EfiMaximumPhase
} EFI_SLEEP_PHASE;
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 Handle of this dispatch function.
@param DispatchContext 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.
Nothing
**/
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 Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function which Sx state type and phase the caller
wishes to be called back on. For this intertace,
the Sx driver will call the registered handlers for
all Sx type and phases, so the Sx state handler(s)
must check the Type and Phase field of the Dispatch
context and act accordingly.
@param DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_UNSUPPORTED The Sx driver or hardware does not support that
Sx Type/Phase.
@retval EFI_DEVICE_ERROR The Sx driver was unable to enable the SMI source.
@retval EFI_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 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
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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.
@retval other TBD
**/
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
//
/**
@par Protocol Description:
Provides the parent dispatch service for a given Sx-state source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
**/
struct _EFI_SMM_SX_DISPATCH_PROTOCOL {
EFI_SMM_SX_REGISTER Register;
EFI_SMM_SX_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmSxDispatchProtocolGuid;
#endif

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

@@ -0,0 +1,141 @@
/** @file
This file declares EFI Smm USB Smi Child Protocol.
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: SmmUsbDispatch.h
@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_
//
// 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;
//
// Related Definitions
//
typedef enum {
UsbLegacy,
UsbWake
} EFI_USB_SMI_TYPE;
typedef struct {
EFI_USB_SMI_TYPE Type;
EFI_DEVICE_PATH_PROTOCOL *Device;
} EFI_SMM_USB_DISPATCH_CONTEXT;
//
// Member functions
//
/**
Dispatch function for a USB SMI handler.
@param DispatchHandle Handle of this dispatch function.
@param DispatchContext Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Nothing
**/
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 This Protocol instance pointer.
@param DispatchFunction Pointer to dispatch function to be invoked for
this SMI source
@param DispatchContext 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 DispatchHandle Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_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
);
/**
Unregister a child SMI source dispatch function with a parent SMM driver
@param This Protocol instance pointer.
@param DispatchHandle Handle of dispatch function to deregister.
@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_USB_UNREGISTER) (
IN EFI_SMM_USB_DISPATCH_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
);
//
// Interface structure for the SMM USB SMI Dispatch Protocol
//
/**
@par Protocol Description:
Provides the parent dispatch service for the USB SMI source generator.
@param Register
Installs a child service to be dispatched by this protocol.
@param UnRegister
Removes a child service dispatched by this protocol.
**/
struct _EFI_SMM_USB_DISPATCH_PROTOCOL {
EFI_SMM_USB_REGISTER Register;
EFI_SMM_USB_UNREGISTER UnRegister;
};
extern EFI_GUID gEfiSmmUsbDispatchProtocolGuid;
#endif