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

OvmfPkg: Copy the required CSM components from framework packages

Browse Source 
REF:https://bugzilla.tianocore.org/show_bug.cgi?id=1811

This commit copies the exact:

Drivers:
* VideoDxe
* LegacyBiosDxe

Libraries:
* LegacyBootMaintUiLib
* LegacyBootManagerLib

Guid header files:
* Legacy Bios Guid
* LegacyDevOrder Guid

Protocol header files:
* Firmware Volume Protocol
* ISA ACPI Protocol
* ISA I/O Protocol
* Legacy BIOS Protocol
* Legacy BIOS Platform Protocol
* Legacy Interrupt Protocol
* VGA Mini Port Protocol

Framework header files (within IntelFrameworkPkg):
* FrameworkDxe.h
* Framework/BootScript.h
* Framework/DxeCis.h
* Framework/FirmwareVolumeHeader.h
* Framework/FirmwareVolumeImageFormat.h
* Framework/FrameworkInternalFormRepresentation.h
* Framework/Hob.h
* Framework/StatusCode.h

from IntelFramework[Module]Pkg to OvmfPkg/Csm/ folder.

Cc: Ray Ni <ray.ni@intel.com>
Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Hao A Wu <hao.a.wu@intel.com>
Reviewed-by: David Woodhouse <dwmw2@infradead.org>
Reviewed-by: Laszlo Ersek <lersek@redhat.com>
This commit is contained in:
Hao A Wu
2019-05-15 11:22:29 +08:00
parent bb4485d388
commit b522c77bdb
50 changed files with 22879 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

340
OvmfPkg/Csm/Include/Protocol/FirmwareVolume.h Normal file
View File

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

298
OvmfPkg/Csm/Include/Protocol/IsaAcpi.h Normal file
View File

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

356
OvmfPkg/Csm/Include/Protocol/IsaIo.h Normal file
View File

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

1553
OvmfPkg/Csm/Include/Protocol/LegacyBios.h Normal file
View File

File diff suppressed because it is too large Load Diff

755
OvmfPkg/Csm/Include/Protocol/LegacyBiosPlatform.h Normal file
View File

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

122
OvmfPkg/Csm/Include/Protocol/LegacyInterrupt.h Normal file
View File

@@ -0,0 +1,122 @@
/** @file
This protocol abstracts the PIRQ programming from the generic EFI Compatibility Support Modules (CSMs).
Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
@par Revision Reference:
This protocol is defined in Framework for the EFI Compatibility Support Module specification.
Version 0.97.
**/
#ifndef _EFI_LEGACY_INTERRUPT_H_
#define _EFI_LEGACY_INTERRUPT_H_
#define EFI_LEGACY_INTERRUPT_PROTOCOL_GUID \
{ \
0x31ce593d, 0x108a, 0x485d, {0xad, 0xb2, 0x78, 0xf2, 0x1f, 0x29, 0x66, 0xbe } \
}
typedef struct _EFI_LEGACY_INTERRUPT_PROTOCOL EFI_LEGACY_INTERRUPT_PROTOCOL;
/**
Get the number of PIRQs this hardware supports.
@param This The protocol instance pointer.
@param NumberPirsq The number of PIRQs that are supported.
@retval EFI_SUCCESS The number of PIRQs was returned successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_GET_NUMBER_PIRQS)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
OUT UINT8 *NumberPirqs
);
/**
Gets the PCI location associated with this protocol.
@param This The Protocol instance pointer.
@param Bus The PCI Bus.
@param Device The PCI Device.
@param Function The PCI Function.
@retval EFI_SUCCESS The Bus, Device, and Function were returned successfully.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_GET_LOCATION)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
OUT UINT8 *Bus,
OUT UINT8 *Device,
OUT UINT8 *Function
);
/**
Read the PIRQ register and return the data
@param This The protocol instance pointer.
@param PirqNumber The PIRQ register to read.
@param PirqData The data read.
@retval EFI_SUCCESS The data was read.
@retval EFI_INVALID_PARAMETER Invalid PIRQ number.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_READ_PIRQ)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
IN UINT8 PirqNumber,
OUT UINT8 *PirqData
);
/**
Write the specified PIRQ register with the given data.
@param This The protocol instance pointer.
@param PirqNumber A PIRQ register to read.
@param PirqData The data to write.
@retval EFI_SUCCESS The PIRQ was programmed.
@retval EFI_INVALID_PARAMETER Invalid PIRQ number.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_WRITE_PIRQ)(
IN EFI_LEGACY_INTERRUPT_PROTOCOL *This,
IN UINT8 PirqNumber,
IN UINT8 PirqData
);
struct _EFI_LEGACY_INTERRUPT_PROTOCOL {
///
/// Gets the number of PIRQs supported.
///
EFI_LEGACY_INTERRUPT_GET_NUMBER_PIRQS GetNumberPirqs;
///
/// Gets the PCI bus, device, and function that is associated with this protocol.
///
EFI_LEGACY_INTERRUPT_GET_LOCATION GetLocation;
///
/// Reads the indicated PIRQ register.
///
EFI_LEGACY_INTERRUPT_READ_PIRQ ReadPirq;
///
/// Writes to the indicated PIRQ register.
///
EFI_LEGACY_INTERRUPT_WRITE_PIRQ WritePirq;
};
extern EFI_GUID gEfiLegacyInterruptProtocolGuid;
#endif

88
OvmfPkg/Csm/Include/Protocol/VgaMiniPort.h Normal file
View File

@@ -0,0 +1,88 @@
/** @file
The VGA Mini Port Protocol used to set the text display mode of a VGA controller.
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef __VGA_MINI_PORT_H_
#define __VGA_MINI_PORT_H_
///
/// Global ID for the EFI_VGA_MINI_PORT_PROTOCOL.
///
#define EFI_VGA_MINI_PORT_PROTOCOL_GUID \
{ \
0xc7735a2f, 0x88f5, 0x4882, {0xae, 0x63, 0xfa, 0xac, 0x8c, 0x8b, 0x86, 0xb3 } \
}
///
/// Forward declaration for the EFI_VGA_MINI_PORT_PROTOCOL.
///
typedef struct _EFI_VGA_MINI_PORT_PROTOCOL EFI_VGA_MINI_PORT_PROTOCOL;
/**
Sets the text display mode of a VGA controller.
Sets the text display mode of the VGA controller to the mode specified by
ModeNumber. A ModeNumber of 0 is a request for an 80x25 text mode. A
ModeNumber of 1 is a request for an 80x50 text mode. If ModeNumber is greater
than MaxModeNumber, then EFI_UNSUPPORTED is returned. If the VGA controller
is not functioning properly, then EFI_DEVICE_ERROR is returned. If the VGA
controller is sucessfully set to the mode number specified by ModeNumber, then
EFI_SUCCESS is returned.
@param[in] This A pointer to the EFI_VGA_MINI_PORT_PROTOCOL instance.
@param[in] ModeNumber The requested mode number. 0 for 80x25. 1 for 80x5.
@retval EFI_SUCCESS The mode number was set.
@retval EFI_UNSUPPORTED The mode number specified by ModeNumber is not supported.
@retval EFI_DEVICE_ERROR The device is not functioning properly.
**/
typedef
EFI_STATUS
(EFIAPI *EFI_VGA_MINI_PORT_SET_MODE)(
IN EFI_VGA_MINI_PORT_PROTOCOL *This,
IN UINTN ModeNumber
);
struct _EFI_VGA_MINI_PORT_PROTOCOL {
EFI_VGA_MINI_PORT_SET_MODE SetMode;
///
/// MMIO base address of the VGA text mode framebuffer. Typically set to 0xB8000.
///
UINT64 VgaMemoryOffset;
///
/// I/O Port address for the VGA CRTC address register. Typically set to 0x3D4.
///
UINT64 CrtcAddressRegisterOffset;
///
/// I/O Port address for the VGA CRTC data register. Typically set to 0x3D5.
///
UINT64 CrtcDataRegisterOffset;
///
/// PCI Controller MMIO BAR index of the VGA text mode frame buffer. Typically
/// set to EFI_PCI_IO_PASS_THROUGH_BAR
///
UINT8 VgaMemoryBar;
///
/// PCI Controller I/O BAR index of the VGA CRTC address register. Typically
/// set to EFI_PCI_IO_PASS_THROUGH_BAR
///
UINT8 CrtcAddressRegisterBar;
///
/// PCI Controller I/O BAR index of the VGA CRTC data register. Typically set
/// to EFI_PCI_IO_PASS_THROUGH_BAR
///
UINT8 CrtcDataRegisterBar;
///
/// The maximum number of text modes that this VGA controller supports.
///
UINT8 MaxMode;
};
extern EFI_GUID gEfiVgaMiniPortProtocolGuid;
#endif