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

Add in the 1st version of ECP.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2832 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
qwang12
2007-06-28 07:00:39 +00:00
parent 30d4a0c7ec
commit 3eb9473ea9
1433 changed files with 266617 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
EdkCompatibilityPkg/Foundation/Framework/Protocol/AcpiS3Save/AcpiS3Save.c Normal file
View File

@@ -0,0 +1,28 @@
/*++
Copyright (c) 2004, 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:
AcpiS3Save.c
Abstract:
Tiano Tiano S3 Save Protocol
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (AcpiS3Save)
EFI_GUID gEfiAcpiS3SaveGuid = EFI_ACPI_S3_SAVE_GUID;
EFI_GUID_STRING(&gEfiAcpiS3SaveGuid, "EFI Acpi S3 Save Protocol", "Tiano Acpi S3 Save Protocol");

68
EdkCompatibilityPkg/Foundation/Framework/Protocol/AcpiS3Save/AcpiS3Save.h Normal file
View File

@@ -0,0 +1,68 @@
/*++
Copyright (c) 2004, 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:
AcpiS3Save.h
Abstract:
--*/
#ifndef _ACPI_S3_SAVE_PROTOCOL_H
#define _ACPI_S3_SAVE_PROTOCOL_H
//
// Includes
//
#include "Tiano.h"
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_ACPI_S3_SAVE_PROTOCOL);
//
// S3 Save Protocol GUID
//
#define EFI_ACPI_S3_SAVE_GUID \
{ \
0x125f2de1, 0xfb85, 0x440c, 0xa5, 0x4c, 0x4d, 0x99, 0x35, 0x8a, 0x8d, 0x38 \
}
//
// Protocol Data Structures
//
typedef
EFI_STATUS
EFI_BOOTSERVICE
(EFIAPI *EFI_ACPI_S3_SAVE) (
IN EFI_ACPI_S3_SAVE_PROTOCOL * This,
IN VOID * LegacyMemoryAddress
);
typedef
EFI_STATUS
EFI_BOOTSERVICE
(EFIAPI *EFI_ACPI_GET_LEGACY_MEMORY_SIZE) (
IN EFI_ACPI_S3_SAVE_PROTOCOL * This,
OUT UINTN * Size
);
typedef struct _EFI_ACPI_S3_SAVE_PROTOCOL {
EFI_ACPI_GET_LEGACY_MEMORY_SIZE GetLegacyMemorySize;
EFI_ACPI_S3_SAVE S3Save;
} EFI_ACPI_S3_SAVE_PROTOCOL;
extern EFI_GUID gEfiAcpiS3SaveGuid;
#endif

29
EdkCompatibilityPkg/Foundation/Framework/Protocol/AcpiSupport/AcpiSupport.c Normal file
View File

@@ -0,0 +1,29 @@
/*++
Copyright (c) 1999 - 2005, 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.c
Abstract:
Tiano EFI 2.0 ACPI Support Protocol
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (AcpiSupport)
EFI_GUID gEfiAcpiSupportGuid = EFI_ACPI_SUPPORT_GUID;
EFI_GUID_STRING(&gEfiAcpiSupportGuid, "ACPI Support Protocol", "EFI 2.0 ACPI Support Protocol");

128
EdkCompatibilityPkg/Foundation/Framework/Protocol/AcpiSupport/AcpiSupport.h Normal file
View File

@@ -0,0 +1,128 @@
/*++
Copyright (c) 1999 - 2005, 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
Abstract:
Definition of the ACPI Support protocol. This is defined in the
Tiano ACPI External Product Specification, revision 0.5.1.
--*/
#ifndef _ACPI_SUPPORT_PROTOCOL_H_
#define _ACPI_SUPPORT_PROTOCOL_H_
//
// Includes
//
#include "Tiano.h"
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_ACPI_SUPPORT_PROTOCOL);
//
// ACPI Support Protocol GUID
//
#define EFI_ACPI_SUPPORT_GUID \
{ \
0xdbff9d55, 0x89b7, 0x46da, 0xbd, 0xdf, 0x67, 0x7d, 0x3d, 0xc0, 0x24, 0x1d \
}
//
// Extern the GUID for protocol users.
//
extern EFI_GUID gEfiAcpiSupportGuid;
//
// 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
//
//
// Retrieve a copy of an ACPI table and the handle of the table.
//
typedef
EFI_STATUS
EFI_BOOTSERVICE
(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
);
//
// Add, update, or remove a table.
//
typedef
EFI_STATUS
EFI_BOOTSERVICE
(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
);
//
// Publish tables to the outside world
//
typedef
EFI_STATUS
EFI_BOOTSERVICE
(EFIAPI *EFI_ACPI_PUBLISH_TABLES) (
IN EFI_ACPI_SUPPORT_PROTOCOL * This,
IN EFI_ACPI_TABLE_VERSION Version
);
//
// ACPI Support Protocol
//
typedef struct _EFI_ACPI_SUPPORT_PROTOCOL {
EFI_ACPI_GET_ACPI_TABLE GetAcpiTable;
EFI_ACPI_SET_ACPI_TABLE SetAcpiTable;
EFI_ACPI_PUBLISH_TABLES PublishTables;
} EFI_ACPI_SUPPORT_PROTOCOL;
#endif

28
EdkCompatibilityPkg/Foundation/Framework/Protocol/BootScriptSave/BootScriptSave.c Normal file
View File

@@ -0,0 +1,28 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
BootScriptSave.c
Abstract:
S3 Save Protocol
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (BootScriptSave)
EFI_GUID gEfiBootScriptSaveGuid = EFI_BOOT_SCRIPT_SAVE_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiBootScriptSaveGuid, "EFI Boot Script Save Protocol", "EFI Boot Script Save Protocol");

75
EdkCompatibilityPkg/Foundation/Framework/Protocol/BootScriptSave/BootScriptSave.h Normal file
View File

@@ -0,0 +1,75 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
BootScriptSave.h
Abstract:
S3 Save Protocol
--*/
#ifndef _BOOT_SCRIPT_SAVE_PROTOCOL_H
#define _BOOT_SCRIPT_SAVE_PROTOCOL_H
//
// Includes
//
#include "Tiano.h"
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_BOOT_SCRIPT_SAVE_PROTOCOL);
//
// S3 Save Protocol GUID
//
#define EFI_BOOT_SCRIPT_SAVE_PROTOCOL_GUID \
{ \
0x470e1529, 0xb79e, 0x4e32, 0xa0, 0xfe, 0x6a, 0x15, 0x6d, 0x29, 0xf9, 0xb2 \
}
//
// Protocol Data Structures
//
typedef
EFI_STATUS
EFI_BOOTSERVICE
(EFIAPI *EFI_BOOT_SCRIPT_WRITE) (
IN EFI_BOOT_SCRIPT_SAVE_PROTOCOL * This,
IN UINT16 TableName,
IN UINT16 OpCode,
...
);
typedef
EFI_STATUS
EFI_BOOTSERVICE
(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
//
typedef struct _EFI_BOOT_SCRIPT_SAVE_PROTOCOL {
EFI_BOOT_SCRIPT_WRITE Write;
EFI_BOOT_SCRIPT_CLOSE_TABLE CloseTable;
} EFI_BOOT_SCRIPT_SAVE_PROTOCOL;
extern EFI_GUID gEfiBootScriptSaveGuid;
#endif

28
EdkCompatibilityPkg/Foundation/Framework/Protocol/CpuIo/CpuIo.c Normal file
View File

@@ -0,0 +1,28 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
CPU IO Protocol GUID as defined in Tiano
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (CpuIo)
EFI_GUID gEfiCpuIoProtocolGuid = EFI_CPU_IO_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiCpuIoProtocolGuid, "CPU IO", "CPU IO Protocol");

93
EdkCompatibilityPkg/Foundation/Framework/Protocol/CpuIo/CpuIo.h Normal file
View File

@@ -0,0 +1,93 @@
/*++
Copyright (c) 2004, 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
Abstract:
CPU IO Protocol as defined in Tiano
This code abstracts the CPU IO Protocol
--*/
#ifndef _CPUIO_H_
#define _CPUIO_H_
#define EFI_CPU_IO_PROTOCOL_GUID \
{ \
0xB0732526, 0x38C8, 0x4b40, 0x88, 0x77, 0x61, 0xC7, 0xB0, 0x6A, 0xAC, 0x45 \
}
EFI_FORWARD_DECLARATION (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
// *******************************************************
//
typedef
EFI_STATUS
EFI_RUNTIMESERVICE
(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
// *******************************************************
//
typedef struct _EFI_CPU_IO_PROTOCOL {
EFI_CPU_IO_PROTOCOL_ACCESS Mem;
EFI_CPU_IO_PROTOCOL_ACCESS Io;
} EFI_CPU_IO_PROTOCOL;
extern EFI_GUID gEfiCpuIoProtocolGuid;
#endif

32
EdkCompatibilityPkg/Foundation/Framework/Protocol/DataHub/DataHub.c Normal file
View File

@@ -0,0 +1,32 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
The logging hub protocol is used both by agents wishing to log
errors 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.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (DataHub)
EFI_GUID gEfiDataHubProtocolGuid = EFI_DATA_HUB_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiDataHubProtocolGuid, "DataHub Protocol", "EFI Data Hub Protocol");

125
EdkCompatibilityPkg/Foundation/Framework/Protocol/DataHub/DataHub.h Normal file
View File

@@ -0,0 +1,125 @@
/*++
Copyright (c) 2004, 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
Abstract:
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.
--*/
#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
//
EFI_FORWARD_DECLARATION (EFI_DATA_HUB_PROTOCOL);
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
);
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
);
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
);
typedef
EFI_STATUS
(EFIAPI *EFI_DATA_HUB_UNREGISTER_FILTER_DRIVER) (
IN EFI_DATA_HUB_PROTOCOL * This,
IN EFI_EVENT FilterEvent
);
typedef 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;
} EFI_DATA_HUB_PROTOCOL;
extern EFI_GUID gEfiDataHubProtocolGuid;
#endif

116
EdkCompatibilityPkg/Foundation/Framework/Protocol/EdkFrameworkProtocolLib.inf Normal file
View File

@@ -0,0 +1,116 @@
#/*++
#
# Copyright (c) 2004, 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:
#
# EdkFrameworkProtocolLib.inf
#
# Abstract:
#
# Component description file.
#
#--*/
[defines]
BASE_NAME= EdkFrameworkProtocolLib
COMPONENT_TYPE= LIBRARY
[includes.common]
$(EDK_SOURCE)\Foundation\Framework
$(EDK_SOURCE)\Foundation\Efi
$(EDK_SOURCE)\Foundation\Include
$(EDK_SOURCE)\Foundation\Efi\Include
$(EDK_SOURCE)\Foundation\Framework\Include
$(EDK_SOURCE)\Foundation\Include\IndustryStandard
$(EDK_SOURCE)\Foundation\Include\Pei
$(EDK_SOURCE)\Foundation\Library\Pei\Include
$(EDK_SOURCE)\Foundation\Core\Dxe
$(EDK_SOURCE)\Foundation\Library\Dxe\Include
[nmake.common]
[sources.common]
AcpiS3Save\AcpiS3Save.h
AcpiS3Save\AcpiS3Save.c
AcpiSupport\AcpiSupport.h
AcpiSupport\AcpiSupport.c
BootScriptSave\BootScriptSave.h
BootScriptSave\BootScriptSave.c
CpuIo\CpuIo.h
CpuIo\CpuIo.c
DataHub\DataHub.h
DataHub\DataHub.c
FirmwareVolume\FirmwareVolume.h
FirmwareVolume\FirmwareVolume.c
FirmwareVolume2\FirmwareVolume2.h
FirmwareVolume2\FirmwareVolume2.c
FirmwareVolumeBlock\FirmwareVolumeBlock.h
FirmwareVolumeBlock\FirmwareVolumeBlock.c
FormBrowser\FormBrowser.h
FormBrowser\FormBrowser.c
FormCallback\FormCallback.h
FormCallback\FormCallback.c
Hii\Hii.h
Hii\Hii.c
IdeControllerInit\IdeControllerInit.h
IdeControllerInit\IdeControllerInit.c
IncompatiblePciDeviceSupport\IncompatiblePciDeviceSupport.h
IncompatiblePciDeviceSupport\IncompatiblePciDeviceSupport.c
Legacy8259\Legacy8259.h
Legacy8259\Legacy8259.c
LegacyBios\LegacyBios.h
LegacyBios\LegacyBios.c
LegacyBiosPlatform\LegacyBiosPlatform.h
LegacyBiosPlatform\LegacyBiosPlatform.c
LegacyInterrupt\LegacyInterrupt.h
LegacyInterrupt\LegacyInterrupt.c
LegacyRegion\LegacyRegion.h
LegacyRegion\LegacyRegion.c
PciHostBridgeResourceAllocation\PciHostBridgeResourceAllocation.h
PciHostBridgeResourceAllocation\PciHostBridgeResourceAllocation.c
PciHotPlugInit\PciHotPlugInit.h
PciHotPlugInit\PciHotPlugInit.c
PciPlatform\PciPlatform.h
PciPlatform\PciPlatform.c
SectionExtraction\SectionExtraction.h
SectionExtraction\SectionExtraction.c
SecurityPolicy\SecurityPolicy.h
SecurityPolicy\SecurityPolicy.c
Smbus\Smbus.h
Smbus\Smbus.c
[sources.ia32,sources.x64]
SmmAccess\SmmAccess.h
SmmAccess\SmmAccess.c
SmmBase\SmmBase.h
SmmBase\SmmBase.c
SmmControl\SmmControl.h
SmmControl\SmmControl.c
SmmCpuState\SmmCpuState.h
SmmCpuState\SmmCpuState.c
SmmGpiDispatch\SmmGpiDispatch.h
SmmGpiDispatch\SmmGpiDispatch.c
SmmIchnDispatch\SmmIchnDispatch.h
SmmIchnDispatch\SmmIchnDispatch.c
SmmPeriodicTimerDispatch\SmmPeriodicTimerDispatch.h
SmmPeriodicTimerDispatch\SmmPeriodicTimerDispatch.c
SmmPowerButtonDispatch\SmmPowerButtonDispatch.h
SmmPowerButtonDispatch\SmmPowerButtonDispatch.c
SmmStandbyButtonDispatch\SmmStandbyButtonDispatch.h
SmmStandbyButtonDispatch\SmmStandbyButtonDispatch.c
SmmStatusCode\SmmStatusCode.h
SmmStatusCode\SmmStatusCode.c
SmmSwDispatch\SmmSwDispatch.h
SmmSwDispatch\SmmSwDispatch.c
SmmSxDispatch\SmmSxDispatch.h
SmmSxDispatch\SmmSxDispatch.c
SmmUsbDispatch\SmmUsbDispatch.h
SmmUsbDispatch\SmmUsbDispatch.c

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/FirmwareVolume/FirmwareVolume.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
Firmware Volume protocol as defined in the Tiano Firmware Volume
specification.
File level access layered on top of Firmware File System protocol. This
protocol exists to provide a hook for a filter driver for a firmware volume.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (FirmwareVolume)
EFI_GUID gEfiFirmwareVolumeProtocolGuid = EFI_FIRMWARE_VOLUME_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiFirmwareVolumeProtocolGuid, "FirmwareVolume Protocol", "Firmware Volume protocol");

301
EdkCompatibilityPkg/Foundation/Framework/Protocol/FirmwareVolume/FirmwareVolume.h Normal file
View File

@@ -0,0 +1,301 @@
/*++
Copyright (c) 2004, 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
Abstract:
Firmware Volume protocol as defined in the Tiano Firmware Volume
specification.
--*/
#ifndef _FW_VOL_H_
#define _FW_VOL_H_
//
// Statements that include other files
//
#include "EfiFirmwareVolumeHeader.h"
#include "EfiFirmwareFileSystem.h"
#include "EfiFirmwareVolume.h"
//
// Firmware Volume Protocol GUID definition
//
#define EFI_FIRMWARE_VOLUME_PROTOCOL_GUID \
{ \
0x389F751F, 0x1838, 0x4388, 0x83, 0x90, 0xCD, 0x81, 0x54, 0xBD, 0x27, 0xF8 \
}
EFI_FORWARD_DECLARATION (EFI_FIRMWARE_VOLUME_PROTOCOL);
//
// ************************************************************
// EFI_FV_ATTRIBUTES bit definitions
// ************************************************************
//
#define EFI_FV_READ_DISABLE_CAP 0x0000000000000001
#define EFI_FV_READ_ENABLE_CAP 0x0000000000000002
#define EFI_FV_READ_STATUS 0x0000000000000004
#define EFI_FV_WRITE_DISABLE_CAP 0x0000000000000008
#define EFI_FV_WRITE_ENABLE_CAP 0x0000000000000010
#define EFI_FV_WRITE_STATUS 0x0000000000000020
#define EFI_FV_LOCK_CAP 0x0000000000000040
#define EFI_FV_LOCK_STATUS 0x0000000000000080
#define EFI_FV_WRITE_POLICY_RELIABLE 0x0000000000000100
#define EFI_FV_ALIGNMENT_CAP 0x0000000000008000
#define EFI_FV_ALIGNMENT_2 0x0000000000010000
#define EFI_FV_ALIGNMENT_4 0x0000000000020000
#define EFI_FV_ALIGNMENT_8 0x0000000000040000
#define EFI_FV_ALIGNMENT_16 0x0000000000080000
#define EFI_FV_ALIGNMENT_32 0x0000000000100000
#define EFI_FV_ALIGNMENT_64 0x0000000000200000
#define EFI_FV_ALIGNMENT_128 0x0000000000400000
#define EFI_FV_ALIGNMENT_256 0x0000000000800000
#define EFI_FV_ALIGNMENT_512 0x0000000001000000
#define EFI_FV_ALIGNMENT_1K 0x0000000002000000
#define EFI_FV_ALIGNMENT_2K 0x0000000004000000
#define EFI_FV_ALIGNMENT_4K 0x0000000008000000
#define EFI_FV_ALIGNMENT_8K 0x0000000010000000
#define EFI_FV_ALIGNMENT_16K 0x0000000020000000
#define EFI_FV_ALIGNMENT_32K 0x0000000040000000
#define EFI_FV_ALIGNMENT_64K 0x0000000080000000
//
// Protocol API definitions
//
//
// Forward declaration of protocol data structure
//
typedef struct _EFI_FIRMWARE_VOLUME_PROTOCOL EFI_FIRMWARE_VOLUME_PROTOCOL;
typedef
EFI_STATUS
(EFIAPI *FV_GET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_PROTOCOL * This,
OUT EFI_FV_ATTRIBUTES * Attributes
);
/*++
Routine Description:
Retrieves attributes, insures positive polarity of attribute bits, returns
resulting attributes in output parameter
Arguments:
This - Calling context
Attributes - output buffer which contains attributes
Returns:
EFI_INVALID_PARAMETER
EFI_SUCCESS
--*/
typedef
EFI_STATUS
(EFIAPI *FV_SET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_PROTOCOL * This,
IN OUT EFI_FV_ATTRIBUTES * Attributes
);
/*++
Routine Description:
Sets volume attributes
Arguments:
This Calling context
Attributes Buffer which contains attributes
Returns:
EFI_INVALID_PARAMETER
EFI_DEVICE_ERROR
EFI_SUCCESS
--*/
typedef
EFI_STATUS
(EFIAPI *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
);
/*++
Routine Description:
Read the requested file (NameGuid) and returns data in Buffer.
Arguments:
This - Calling context
NameGuid - Filename identifying which file to read
Buffer - Pointer to pointer to buffer in which contents of file are returned.
If Buffer is NULL, only type, attributes, and size are returned as
there is no output buffer.
If Buffer != NULL and *Buffer == NULL, the output buffer is allocated
from BS pool by ReadFile
If Buffer != NULL and *Buffer != NULL, the output buffer has been
allocated by the caller and is being passed in.
BufferSize - Indicates the buffer size passed in, and on output the size
required to complete the read
FoundType - Indicates the type of the file who's data is returned
FileAttributes - Indicates the attributes of the file who's data is resturned
AuthenticationStatus - Indicates the authentication status of the data
Returns:
EFI_SUCCESS
EFI_WARN_BUFFER_TOO_SMALL
EFI_NOT_FOUND
EFI_DEVICE_ERROR
EFI_ACCESS_DENIED
--*/
typedef
EFI_STATUS
(EFIAPI *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
);
/*++
Routine Description:
Read the requested section from the specified file and returns data in Buffer.
Arguments:
This - Calling context
NameGuid - Filename identifying the file from which to read
SectionType - Indicates what section type to retrieve
SectionInstance - Indicates which instance of SectionType to retrieve
Buffer - Pointer to pointer to buffer in which contents of file are returned.
If Buffer is NULL, only type, attributes, and size are returned as
there is no output buffer.
If Buffer != NULL and *Buffer == NULL, the output buffer is allocated
from BS pool by ReadFile
If Buffer != NULL and *Buffer != NULL, the output buffer has been
allocated by the caller and is being passed in.
BufferSize - Indicates the buffer size passed in, and on output the size
required to complete the read
AuthenticationStatus - Indicates the authentication status of the data
Returns:
EFI_SUCCESS
EFI_WARN_BUFFER_TOO_SMALL
EFI_OUT_OF_RESOURCES
EFI_NOT_FOUND
EFI_DEVICE_ERROR
EFI_ACCESS_DENIED
--*/
typedef
EFI_STATUS
(EFIAPI *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
);
/*++
Routine Description:
Write the supplied file (NameGuid) to the FV.
Arguments:
This - Calling context
NumberOfFiles - Indicates the number of file records pointed to by FileData
WritePolicy - Indicates the level of reliability of the write with respect to
things like power failure events.
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.
Returns:
EFI_SUCCESS
EFI_OUT_OF_RESOURCES
EFI_DEVICE_ERROR
EFI_WRITE_PROTECTED
EFI_NOT_FOUND
EFI_INVALID_PARAMETER
--*/
typedef
EFI_STATUS
(EFIAPI *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
);
/*++
Routine Description:
Given the input key, search for the next matching file in the volume.
Arguments:
This - Calling context
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.
FileType - Indicates the file type to filter for
NameGuid - Guid filename of the file found
Attributes - Attributes of the file found
Size - Size in bytes of the file found
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_DEVICE_ERROR
EFI_ACCESS_DENIED
--*/
typedef struct _EFI_FIRMWARE_VOLUME_PROTOCOL {
FV_GET_ATTRIBUTES GetVolumeAttributes;
FV_SET_ATTRIBUTES SetVolumeAttributes;
FV_READ_FILE ReadFile;
FV_READ_SECTION ReadSection;
FV_WRITE_FILE WriteFile;
FV_GET_NEXT_FILE GetNextFile;
UINT32 KeySize;
EFI_HANDLE ParentHandle;
} EFI_FIRMWARE_VOLUME_PROTOCOL;
extern EFI_GUID gEfiFirmwareVolumeProtocolGuid;
#endif

29
EdkCompatibilityPkg/Foundation/Framework/Protocol/FirmwareVolume2/FirmwareVolume2.c Normal file
View File

@@ -0,0 +1,29 @@
/*++
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:
FirmwareVolume2.c
Abstract:
PI 1.0 spec definition.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (FirmwareVolume2)
EFI_GUID gEfiFirmwareVolume2ProtocolGuid = EFI_FIRMWARE_VOLUME2_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiFirmwareVolume2ProtocolGuid, "FirmwareVolume2Protocol", "Efi FirmwareVolume2Protocol");

195
EdkCompatibilityPkg/Foundation/Framework/Protocol/FirmwareVolume2/FirmwareVolume2.h Normal file
View File

@@ -0,0 +1,195 @@
/*++
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:
FirmwareVolume2.h
Abstract:
PI 1.0 spec definition.
--*/
#ifndef __FIRMWARE_VOLUME2_H__
#define __FIRMWARE_VOLUME2_H__
#include "EfiImageFormat.h"
#include "EfiFirmwareVolume.h"
//
// Firmware Volume Protocol GUID definition
//
#define EFI_FIRMWARE_VOLUME2_PROTOCOL_GUID \
{ 0x220e73b6, 0x6bdb, 0x4413, 0x84, 0x5, 0xb9, 0x74, 0xb1, 0x8, 0x61, 0x9a }
EFI_FORWARD_DECLARATION (EFI_FIRMWARE_VOLUME2_PROTOCOL);
//
// ************************************************************
// EFI_FV2_ATTRIBUTES bit definitions
// ************************************************************
//
#define EFI_FV2_READ_DISABLE_CAP 0x0000000000000001
#define EFI_FV2_READ_ENABLE_CAP 0x0000000000000002
#define EFI_FV2_READ_STATUS 0x0000000000000004
#define EFI_FV2_WRITE_DISABLE_CAP 0x0000000000000008
#define EFI_FV2_WRITE_ENABLE_CAP 0x0000000000000010
#define EFI_FV2_WRITE_STATUS 0x0000000000000020
#define EFI_FV2_LOCK_CAP 0x0000000000000040
#define EFI_FV2_LOCK_STATUS 0x0000000000000080
#define EFI_FV2_WRITE_POLICY_RELIABLE 0x0000000000000100
#define EFI_FV2_READ_LOCK_CAP 0x0000000000001000
#define EFI_FV2_READ_LOCK_STATUS 0x0000000000002000
#define EFI_FV2_WRITE_LOCK_CAP 0x0000000000004000
#define EFI_FV2_WRITE_LOCK_STATUS 0x0000000000008000
#define EFI_FV2_ALIGNMENT 0x00000000001F0000
#define EFI_FV2_ALIGNMENT_1 0x0000000000000000
#define EFI_FV2_ALIGNMENT_2 0x0000000000010000
#define EFI_FV2_ALIGNMENT_4 0x0000000000020000
#define EFI_FV2_ALIGNMENT_8 0x0000000000030000
#define EFI_FV2_ALIGNMENT_16 0x0000000000040000
#define EFI_FV2_ALIGNMENT_32 0x0000000000050000
#define EFI_FV2_ALIGNMENT_64 0x0000000000060000
#define EFI_FV2_ALIGNMENT_128 0x0000000000070000
#define EFI_FV2_ALIGNMENT_256 0x0000000000080000
#define EFI_FV2_ALIGNMENT_512 0x0000000000090000
#define EFI_FV2_ALIGNMENT_1K 0x00000000000A0000
#define EFI_FV2_ALIGNMENT_2K 0x00000000000B0000
#define EFI_FV2_ALIGNMENT_4K 0x00000000000C0000
#define EFI_FV2_ALIGNMENT_8K 0x00000000000D0000
#define EFI_FV2_ALIGNMENT_16K 0x00000000000E0000
#define EFI_FV2_ALIGNMENT_32K 0x00000000000F0000
#define EFI_FV2_ALIGNMENT_64K 0x0000000000100000
#define EFI_FV2_ALIGNMENT_128K 0x0000000000110000
#define EFI_FV2_ALIGNMENT_256K 0x0000000000120000
#define EFI_FV2_ALIGNMENT_512K 0x0000000000130000
#define EFI_FV2_ALIGNMENT_1M 0x0000000000140000
#define EFI_FV2_ALIGNMENT_2M 0x0000000000150000
#define EFI_FV2_ALIGNMENT_4M 0x0000000000160000
#define EFI_FV2_ALIGNMENT_8M 0x0000000000170000
#define EFI_FV2_ALIGNMENT_16M 0x0000000000180000
#define EFI_FV2_ALIGNMENT_32M 0x0000000000190000
#define EFI_FV2_ALIGNMENT_64M 0x00000000001A0000
#define EFI_FV2_ALIGNMENT_128M 0x00000000001B0000
#define EFI_FV2_ALIGNMENT_256M 0x00000000001C0000
#define EFI_FV2_ALIGNMENT_512M 0x00000000001D0000
#define EFI_FV2_ALIGNMENT_1G 0x00000000001E0000
#define EFI_FV2_ALIGNMENT_2G 0x00000000001F0000
#define EFI_FV_FILE_ATTRIB_FIXED 0x00000100
#define EFI_FV_FILE_ATTRIB_MEMORY_MAPPED 0x00000200
//
// Protocol API definitions
//
typedef
EFI_STATUS
(EFIAPI *EFI_FV_GET_ATTRIBUTES) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
OUT EFI_FV_ATTRIBUTES *Attributes
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_SET_ATTRIBUTES) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
IN OUT EFI_FV_ATTRIBUTES *Attributes
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_READ_FILE) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
IN CONST 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
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_READ_SECTION) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
IN CONST EFI_GUID *NameGuid,
IN EFI_SECTION_TYPE SectionType,
IN UINTN SectionInstance,
IN OUT VOID **Buffer,
IN OUT UINTN *BufferSize,
OUT UINT32 *AuthenticationStatus
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_WRITE_FILE) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
IN UINT32 NumberOfFiles,
IN EFI_FV_WRITE_POLICY WritePolicy,
IN EFI_FV_WRITE_FILE_DATA *FileData
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_GET_NEXT_FILE) (
IN CONST EFI_FIRMWARE_VOLUME2_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
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_GET_INFO) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
IN CONST EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_FV_SET_INFO) (
IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
IN CONST EFI_GUID *InformationType,
IN UINTN BufferSize,
IN CONST VOID *Buffer
);
typedef struct _EFI_FIRMWARE_VOLUME2_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;
EFI_FV_GET_INFO GetInfo;
EFI_FV_SET_INFO SetInfo;
} EFI_FIRMWARE_VOLUME2_PROTOCOL;
extern EFI_GUID gEfiFirmwareVolume2ProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/FirmwareVolumeBlock/FirmwareVolumeBlock.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
Firmware Volume Block protocol as defined in the Tiano Firmware Volume
specification.
Low level firmware device access routines to abstract firmware device
hardware.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (FirmwareVolumeBlock)
EFI_GUID gEfiFirmwareVolumeBlockProtocolGuid = EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiFirmwareVolumeBlockProtocolGuid, "FirmwareVolumeBlock Protocol", "Firmware Volume Block protocol");

251
EdkCompatibilityPkg/Foundation/Framework/Protocol/FirmwareVolumeBlock/FirmwareVolumeBlock.h Normal file
View File

@@ -0,0 +1,251 @@
/*++
Copyright (c) 2004, 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
Abstract:
Firmware Volume Block protocol as defined in the Tiano Firmware Volume
specification.
Low level firmware device access routines to abstract firmware device
hardware.
--*/
#ifndef _FW_VOL_BLOCK_H_
#define _FW_VOL_BLOCK_H_
#include "EfiFirmwareVolumeHeader.h"
#define EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID \
{ \
0xDE28BC59, 0x6228, 0x41BD, 0xBD, 0xF6, 0xA3, 0xB9, 0xAD, 0xB5, 0x8D, 0xA1 \
}
EFI_FORWARD_DECLARATION (EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL);
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_GET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL * This,
OUT EFI_FVB_ATTRIBUTES * Attributes
)
/*++
Routine Description:
Retrieves Volume attributes. No polarity translations are done.
Arguments:
This - Calling context
Attributes - output buffer which contains attributes
Returns:
EFI_INVALID_PARAMETER
EFI_SUCCESS
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_SET_ATTRIBUTES) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL * This,
IN OUT EFI_FVB_ATTRIBUTES * Attributes
)
/*++
Routine Description:
Sets Volume attributes. No polarity translations are done.
Arguments:
This - Calling context
Attributes - On input: contains new attributes
On output: contains current attributes of FV
Returns:
EFI_INVALID_PARAMETER
EFI_SUCCESS
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_GET_PHYSICAL_ADDRESS) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL * This,
OUT EFI_PHYSICAL_ADDRESS * Address
)
/*++
Routine Description:
Retrieves the physical address of a memory mapped FV.
Arguments:
This - Calling context
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.
Returns:
EFI_UNSUPPORTED
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
)
/*++
Routine Description:
Retrieves the size in bytes of a specific block within an FV.
Arguments:
This - Calling context.
Lba - Indicates which block to return the size for.
BlockSize - BlockSize is a pointer to a caller allocated
UINTN in which the size of the block is returned.
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.
Returns:
EFI_INVALID_PARAMETER
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
)
/*++
Routine Description:
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.
Arguments:
This - Calling context
Lba - Block in which to begin read
Offset - Offset in the block at which to begin read
NumBytes - At input, indicates the requested read size. At output, indicates
the actual number of bytes read.
Buffer - Data buffer in which to place data read.
Returns:
EFI_INVALID_PARAMETER
EFI_NOT_FOUND
EFI_DEVICE_ERROR
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
)
/*++
Routine Description:
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.
Arguments:
This - Calling context
Lba - Block in which to begin write
Offset - Offset in the block at which to begin write
NumBytes - At input, indicates the requested write size. At output, indicates
the actual number of bytes written.
Buffer - Buffer containing source data for the write.
Returns:
EFI_INVALID_PARAMETER
EFI_NOT_FOUND
EFI_DEVICE_ERROR
EFI_SUCCESS
--*/
;
#define EFI_LBA_LIST_TERMINATOR 0xFFFFFFFFFFFFFFFF
typedef
EFI_STATUS
(EFIAPI *EFI_FVB_ERASE_BLOCKS) (
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL * This,
...
)
/*++
Routine Description:
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.
Arguments:
This - Calling context
... - Starting LBA followed by Number of Lba to erase. a -1 to terminate
the list.
Returns:
EFI_INVALID_PARAMETER
EFI_DEVICE_ERROR
EFI_SUCCESS
EFI_ACCESS_DENIED
--*/
;
typedef 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;
} EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL;
extern EFI_GUID gEfiFirmwareVolumeBlockProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/FormBrowser/FormBrowser.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 2004, 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:
FormBrowser.c
Abstract:
The EFI_FORM_BROWSER_PROTOCOL is the interface to the EFI
Configuration Driver. This will allow the caller to direct the
configuration driver to use either the HII database or use the passed
in packet of data. This will also allow the caller to post messages
into the configuration drivers internal mailbox.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (FormBrowser)
EFI_GUID gEfiFormBrowserProtocolGuid = EFI_FORM_BROWSER_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiFormBrowserProtocolGuid, "Form Browser Protocol", "Form Browser 1.0 protocol");

97
EdkCompatibilityPkg/Foundation/Framework/Protocol/FormBrowser/FormBrowser.h Normal file
View File

@@ -0,0 +1,97 @@
/*++
Copyright (c) 2004, 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:
FormBrowser.h
Abstract:
The EFI_FORM_BROWSER_PROTOCOL is the interface to the EFI
Configuration Driver. This will allow the caller to direct the
configuration driver to use either the HII database or use the passed
in packet of data. This will also allow the caller to post messages
into the configuration drivers internal mailbox.
--*/
#ifndef _FORM_BROWSER_H_
#define _FORM_BROWSER_H_
#include EFI_PROTOCOL_DEFINITION (Hii)
#define EFI_FORM_BROWSER_PROTOCOL_GUID \
{ \
0xe5a1333e, 0xe1b4, 0x4d55, 0xce, 0xeb, 0x35, 0xc3, 0xef, 0x13, 0x34, 0x43 \
}
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_FORM_BROWSER_PROTOCOL);
typedef struct _EFI_FORM_BROWSER_PROTOCOL EFI_FORM_BROWSER_PROTOCOL;
typedef struct {
UINT32 Length;
UINT16 Type;
UINT8 Data[1];
} EFI_HII_PACKET;
typedef struct {
EFI_HII_IFR_PACK *IfrData;
EFI_HII_STRING_PACK *StringData;
} EFI_IFR_PACKET;
typedef struct {
UINTN LeftColumn;
UINTN RightColumn;
UINTN TopRow;
UINTN BottomRow;
} SCREEN_DESCRIPTOR;
//
// The following types are currently defined:
//
typedef
EFI_STATUS
(EFIAPI *EFI_SEND_FORM) (
IN EFI_FORM_BROWSER_PROTOCOL * This,
IN BOOLEAN UseDatabase,
IN EFI_HII_HANDLE * Handle,
IN UINTN HandleCount,
IN EFI_IFR_PACKET * Packet,
IN EFI_HANDLE CallbackHandle,
IN UINT8 *NvMapOverride,
IN SCREEN_DESCRIPTOR * ScreenDimensions,
OUT BOOLEAN *ResetRequired OPTIONAL
);
typedef
EFI_STATUS
(EFIAPI *EFI_CREATE_POP_UP) (
IN UINTN NumberOfLines,
IN BOOLEAN HotKey,
IN UINTN MaximumStringSize,
OUT CHAR16 *StringBuffer,
OUT EFI_INPUT_KEY * KeyValue,
IN CHAR16 *String,
...
);
typedef struct _EFI_FORM_BROWSER_PROTOCOL {
EFI_SEND_FORM SendForm;
EFI_CREATE_POP_UP CreatePopUp;
} EFI_FORM_BROWSER_PROTOCOL;
extern EFI_GUID gEfiFormBrowserProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/FormCallback/FormCallback.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 2004, 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:
FormCallback.c
Abstract:
The EFI_FORM_CALLBACK_PROTOCOL is the defined interface for access to custom
NV storage devices as well as communication of user selections in a more
interactive environment. This protocol should be published by hardware
specific drivers which want to export access to custom hardware storage or
publish IFR which has a requirement to call back the original driver.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (FormCallback)
EFI_GUID gEfiFormCallbackProtocolGuid = EFI_FORM_CALLBACK_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiFormCallbackProtocolGuid, "Form Callback Protocol", "Form Callback 1.0 protocol");

120
EdkCompatibilityPkg/Foundation/Framework/Protocol/FormCallback/FormCallback.h Normal file
View File

@@ -0,0 +1,120 @@
/*++
Copyright (c) 2004, 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:
FormCallback.h
Abstract:
The EFI_FORM_CALLBACK_PROTOCOL is the defined interface for access to custom
NV storage devices as well as communication of user selections in a more
interactive environment. This protocol should be published by hardware
specific drivers which want to export access to custom hardware storage or
publish IFR which has a requirement to call back the original driver.
--*/
#ifndef _FORM_CALLBACK_H_
#define _FORM_CALLBACK_H_
#include EFI_PROTOCOL_DEFINITION (FormBrowser)
#define EFI_FORM_CALLBACK_PROTOCOL_GUID \
{ \
0xf3e4543d, 0xcf35, 0x6cef, 0x35, 0xc4, 0x4f, 0xe6, 0x34, 0x4d, 0xfc, 0x54 \
}
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_FORM_CALLBACK_PROTOCOL);
typedef struct _EFI_FORM_CALLBACK_PROTOCOL EFI_FORM_CALLBACK_PROTOCOL;
#define RESET_REQUIRED 1 // Flags setting to signify that the callback operation resulted in an eventual
// reset to be done upon exit of the browser
//
#define EXIT_REQUIRED 2 // Flags setting to signify that after the processing of the callback results - exit the browser
#define SAVE_REQUIRED 4 // Flags setting to signify that after the processing of the callback results - save the NV data
#define NV_CHANGED 8 // Flags setting to signify that after the processing of the callback results - turn the NV flag on
#define NV_NOT_CHANGED 16 // Flags setting to signify that after the processing of the callback results - turn the NV flag off
#pragma pack(1)
typedef struct {
UINT8 OpCode; // Likely a string, numeric, or one-of
UINT8 Length; // Length of the EFI_IFR_DATA_ENTRY packet
UINT16 Flags; // Flags settings to determine what behavior is desired from the browser after the callback
VOID *Data; // The data in the form based on the op-code type - this is not a pointer to the data, the data follows immediately
// If the OpCode is a OneOf or Numeric type - Data is a UINT16 value
// If the OpCode is a String type - Data is a CHAR16[x] type
// If the OpCode is a Checkbox type - Data is a UINT8 value
// If the OpCode is a NV Access type - Data is a EFI_IFR_NV_DATA structure
//
} EFI_IFR_DATA_ENTRY;
typedef struct {
VOID *NvRamMap; // If the flag of the op-code specified retrieval of a copy of the NVRAM map,
// this is a pointer to a buffer copy
//
UINT32 EntryCount; // How many EFI_IFR_DATA_ENTRY entries
EFI_IFR_DATA_ENTRY Data[1]; // The in-line Data entries.
} EFI_IFR_DATA_ARRAY;
typedef union {
EFI_IFR_DATA_ARRAY DataArray; // Primarily used by those who call back to their drivers and use HII as a repository
EFI_IFR_PACKET DataPacket; // Primarily used by those which do not use HII as a repository
CHAR16 String[1]; // If returning an error - fill the string with null-terminated contents
} EFI_HII_CALLBACK_PACKET;
#pragma pack()
//
// The following types are currently defined:
//
typedef
EFI_STATUS
(EFIAPI *EFI_NV_READ) (
IN EFI_FORM_CALLBACK_PROTOCOL * This,
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_NV_WRITE) (
IN EFI_FORM_CALLBACK_PROTOCOL * This,
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Buffer,
OUT BOOLEAN *ResetRequired
);
typedef
EFI_STATUS
(EFIAPI *EFI_FORM_CALLBACK) (
IN EFI_FORM_CALLBACK_PROTOCOL * This,
IN UINT16 KeyValue,
IN EFI_IFR_DATA_ARRAY * Data,
OUT EFI_HII_CALLBACK_PACKET **Packet
);
typedef struct _EFI_FORM_CALLBACK_PROTOCOL {
EFI_NV_READ NvRead;
EFI_NV_WRITE NvWrite;
EFI_FORM_CALLBACK Callback;
} EFI_FORM_CALLBACK_PROTOCOL;
extern EFI_GUID gEfiFormCallbackProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/Hii/Hii.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
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.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (Hii)
EFI_GUID gEfiHiiProtocolGuid = EFI_HII_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiHiiProtocolGuid, "Human Interface Infrastructure Protocol", "HII 1.0 protocol");

613
EdkCompatibilityPkg/Foundation/Framework/Protocol/Hii/Hii.h Normal file
View File

@@ -0,0 +1,613 @@
/*++
Copyright (c) 2004 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Hii.h
Abstract:
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.
--*/
#ifndef _HII_H_
#define _HII_H_
#include "EfiInternalFormRepresentation.h"
#include EFI_PROTOCOL_DEFINITION (UgaDraw)
#include EFI_PROTOCOL_DEFINITION (GraphicsOutput)
#define EFI_HII_PROTOCOL_GUID \
{ \
0xd7ad636e, 0xb997, 0x459b, 0xbf, 0x3f, 0x88, 0x46, 0x89, 0x79, 0x80, 0xe1 \
}
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_HII_PROTOCOL);
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
#define HANG(foo) { \
volatile INT32 __iii; \
__iii = foo; \
while (__iii) \
; \
}
//
// #define HANG(foo)
//
// 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;
typedef UINT16 EFI_HII_HANDLE;
#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 {
UINT16 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
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;
//
// We use this one to get the real size of the header
//
typedef struct {
EFI_HII_PACK_HEADER Header;
RELOFST LanguageNameString;
RELOFST PrintableLanguageName;
UINT32 NumStringPointers;
UINT32 Attributes;
} EFI_HII_STRING_PACK_HEADER;
//
// Glyph Attributes
//
#define GLYPH_NON_SPACING 1
#define GLYPH_NON_BREAKING 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()
typedef
EFI_STATUS
(EFIAPI *EFI_HII_NEW_PACK) (
IN EFI_HII_PROTOCOL * This,
IN EFI_HII_PACKAGES * Packages,
OUT EFI_HII_HANDLE * Handle
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_REMOVE_PACK) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_FIND_HANDLES) (
IN EFI_HII_PROTOCOL *This,
IN OUT UINT16 *HandleBufferLength,
OUT EFI_HII_HANDLE *Handle
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_EXPORT) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_RESET_STRINGS) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_TEST_STRING) (
IN EFI_HII_PROTOCOL *This,
IN CHAR16 *StringToTest,
IN OUT UINT32 *FirstMissing,
OUT UINT32 *GlyphBufferSize
);
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
);
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
);
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
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_PRI_LANGUAGES) (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_HANDLE Handle,
OUT EFI_STRING *LanguageString
);
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
);
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
);
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
);
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
);
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
);
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
);
typedef
EFI_STATUS
(EFIAPI *EFI_HII_GET_KEYBOARD_LAYOUT) (
IN EFI_HII_PROTOCOL * This,
OUT UINT16 *DescriptorCount,
OUT EFI_KEY_DESCRIPTOR * Descriptor
);
typedef 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;
} EFI_HII_PROTOCOL;
extern EFI_GUID gEfiHiiProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/IdeControllerInit/IdeControllerInit.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
EFI IDE Controller Init Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (IdeControllerInit)
EFI_GUID gEfiIdeControllerInitProtocolGuid = EFI_IDE_CONTROLLER_INIT_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiIdeControllerInitProtocolGuid, "IDE Controller Init Protocol", "Platform IDE Init Protocol");

348
EdkCompatibilityPkg/Foundation/Framework/Protocol/IdeControllerInit/IdeControllerInit.h Normal file
View File

@@ -0,0 +1,348 @@
/*++
Copyright (c) 2004, 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
Abstract:
EFI Platform IDE Init Protocol
Revision History
0.01 - Draft, 5-01-2002
Add Atapi6 Identify structure definition, 8-14-2002
--*/
#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, ANSI compatability
//
EFI_FORWARD_DECLARATION (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
//
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
);
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
);
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
);
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
);
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
);
//
// ?? What happen to EFI_IDE_CONTROLLER_SET_TIMING ???
//
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.
//
typedef 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;
} EFI_IDE_CONTROLLER_INIT_PROTOCOL;
extern EFI_GUID gEfiIdeControllerInitProtocolGuid;
#endif

34
EdkCompatibilityPkg/Foundation/Framework/Protocol/IncompatiblePciDeviceSupport/IncompatiblePciDeviceSupport.c Normal file
View File

@@ -0,0 +1,34 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
EFI Incompatible PCI Device Support Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (IncompatiblePciDeviceSupport)
EFI_GUID gEfiIncompatiblePciDeviceSupportProtocolGuid = EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL_GUID;
EFI_GUID_STRING
(
&gEfiIncompatiblePciDeviceSupportProtocolGuid, "Incompatible PCI Device Support Protocol",
"Tiano Incompatible PCI Device Support Protocol"
);

55
EdkCompatibilityPkg/Foundation/Framework/Protocol/IncompatiblePciDeviceSupport/IncompatiblePciDeviceSupport.h Normal file
View File

@@ -0,0 +1,55 @@
/*++
Copyright (c) 2004, 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
Abstract:
EFI Incompatible PCI Device Support Protocol
Revision History
--*/
#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}
EFI_FORWARD_DECLARATION (EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT);
typedef
EFI_STATUS
(EFIAPI *EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_CHECK_DEVICE) (
IN EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT *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
//
typedef struct _EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT {
EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_CHECK_DEVICE CheckDevice;
} EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL;
extern EFI_GUID gEfiIncompatiblePciDeviceSupportProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/Legacy8259/Legacy8259.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Legacy8259.c
Abstract:
EFI Legacy Region Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (Legacy8259)
EFI_GUID gEfiLegacy8259ProtocolGuid = EFI_LEGACY_8259_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiLegacy8259ProtocolGuid, "Legacy 8259 Protocol", "Legacy 8259 Protocol");

317
EdkCompatibilityPkg/Foundation/Framework/Protocol/Legacy8259/Legacy8259.h Normal file
View File

@@ -0,0 +1,317 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Legacy8259.h
Abstract:
This protocol abstracts the 8259 interrupt controller. This includes
PCI IRQ routing need to program the PCI Interrupt Line register.
Revision History
The EFI Legacy 8259 Protocol is compliant with CSM spec 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 \
}
EFI_FORWARD_DECLARATION (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;
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_SET_VECTOR_BASE) (
IN EFI_LEGACY_8259_PROTOCOL * This,
IN UINT8 MasterBase,
IN UINT8 SlaveBase
)
/*++
Routine Description:
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.
Arguments:
This - Protocol instance pointer.
MasterBase - The base vector for the Master PIC in the 8259 controller
Slavebase - The base vector for the Master PIC in the 8259 controller
Returns:
EFI_SUCCESS - The new bases were programmed
EFI_DEVICE_ERROR - A device erro occured programming the vector bases
--*/
;
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
)
/*++
Routine Description:
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.
Arguments:
This - Protocol instance pointer.
LegacyMask - Bit 0 is Irq0 - Bit 15 is Irq15
LegacyEdgeLevel - Bit 0 is Irq0 - Bit 15 is Irq15
ProtectedMask - Bit 0 is Irq0 - Bit 15 is Irq15
ProtectedEdgeLevel - Bit 0 is Irq0 - Bit 15 is Irq15
Returns:
EFI_SUCCESS - 8259 status returned
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
)
/*++
Routine Description:
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.
Arguments:
This - Protocol instance pointer.
LegacyMask - Bit 0 is Irq0 - Bit 15 is Irq15
LegacyEdgeLevel - Bit 0 is Irq0 - Bit 15 is Irq15
ProtectedMask - Bit 0 is Irq0 - Bit 15 is Irq15
ProtectedEdgeLevel - Bit 0 is Irq0 - Bit 15 is Irq15
Returns:
EFI_SUCCESS - 8259 status returned
EFI_DEVICE_ERROR - Error reading 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
)
/*++
Routine Description:
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.
Arguments:
This - Protocol instance pointer.
Mode - Mode of operation. i.e. real mode or protected mode
Mask - Optional interupt mask for the new mode.
EdgeLevel - Optional trigger mask for the new mode.
Returns:
EFI_SUCCESS - 8259 programmed
EFI_DEVICE_ERROR - Error writting to 8259
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_GET_VECTOR) (
IN EFI_LEGACY_8259_PROTOCOL * This,
IN EFI_8259_IRQ Irq,
OUT UINT8 *Vector
)
/*++
Routine Description:
Convert from IRQ to processor interrupt vector number.
Arguments:
This - Protocol instance pointer.
Irq - 8259 IRQ0 - IRQ15
Vector - Processor vector number that matches Irq
Returns:
EFI_SUCCESS - The Vector matching Irq is returned
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
)
/*++
Routine Description:
Enable Irq by unmasking interrupt in 8259
Arguments:
This - Protocol instance pointer.
Irq - 8259 IRQ0 - IRQ15
LevelTriggered - TRUE if level triggered. FALSE if edge triggered.
Returns:
EFI_SUCCESS - Irq enabled on 8259
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
)
/*++
Routine Description:
Disable Irq by masking interrupt in 8259
Arguments:
This - Protocol instance pointer.
Irq - 8259 IRQ0 - IRQ15
Returns:
EFI_SUCCESS - Irq disabled on 8259
EFI_INVALID_PARAMETER - Irq 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
)
/*++
Routine Description:
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.
Arguments:
This - Protocol instance pointer.
PciHandle - PCI function to return vector for
Vector - Vector for fucntion that matches
Returns:
EFI_SUCCESS - A valid Vector is returned
EFI_INVALID_PARAMETER - PciHandle not valid
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_8259_END_OF_INTERRUPT) (
IN EFI_LEGACY_8259_PROTOCOL * This,
IN EFI_8259_IRQ Irq
)
/*++
Routine Description:
Send an EOI to 8259
Arguments:
This - Protocol instance pointer.
Irq - 8259 IRQ0 - IRQ15
Returns:
EFI_SUCCESS - EOI successfully sent to 8259
EFI_INVALID_PARAMETER - Irq not valid
--*/
;
typedef 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;
} EFI_LEGACY_8259_PROTOCOL;
extern EFI_GUID gEfiLegacy8259ProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyBios/LegacyBios.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
EFI Legacy BIOS Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (LegacyBios)
EFI_GUID gEfiLegacyBiosProtocolGuid = EFI_LEGACY_BIOS_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiLegacyBiosProtocolGuid, "Legacy BIOS Protocol", "Legacy BIOS Protocol");

701
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyBios/LegacyBios.h Normal file
View File

@@ -0,0 +1,701 @@
/*++
Copyright (c) 2004 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
LegacyBios.h
Abstract:
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.
Note: Note: Note: Note: Note: Note: Note:
You most likely should not use this protocol! Find the EFI way to solve the
problem to make your code portable
Note: Note: Note: Note: Note: Note: Note:
Revision History
The EFI Legacy BIOS Protocol is compliant with CSM spec 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 \
}
EFI_FORWARD_DECLARATION (EFI_LEGACY_BIOS_PROTOCOL);
//
// 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
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;
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;
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;
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;
typedef struct {
UINT8 AL;
UINT8 AH;
UINT16 ReservedAX;
UINT8 BL;
UINT8 BH;
UINT16 ReservedBX;
UINT8 CL;
UINT8 CH;
UINT16 ReservedCX;
UINT8 DL;
UINT8 DH;
UINT16 ReservedDX;
} EFI_BYTE_REGS;
typedef union {
EFI_DWORD_REGS E;
EFI_WORD_REGS X;
EFI_BYTE_REGS H;
} EFI_IA32_REGISTER_SET;
#pragma pack(1)
//
// $EFI table created by Legacy16 code and consumed by EFI Legacy driver
//
typedef struct {
UINT32 Signature; // "$EFI"
UINT8 TableChecksum;
UINT8 TableLength;
UINT8 EfiMajorRevision;
UINT8 EfiMinorRevision;
UINT8 TableMajorRevision;
UINT8 TableMinorRevision;
UINT16 Reserved;
UINT16 Compatibility16CallSegment;
UINT16 Compatibility16CallOffset;
UINT16 PnPInstallationCheckSegment;
UINT16 PnPInstallationCheckOffset;
UINT32 EfiSystemTable; // IPF - CSM Integration
UINT32 OemIdStringPointer;
UINT32 AcpiRsdPtrPointer;
UINT16 OemRevision;
UINT32 E820Pointer;
UINT32 E820Length;
UINT32 IrqRoutingTablePointer;
UINT32 IrqRoutingTableLength;
UINT32 MpTablePtr;
UINT32 MpTableLength;
UINT16 OemIntSegment;
UINT16 OemIntOffset;
UINT16 Oem32Segment;
UINT16 Oem32Offset;
UINT16 Oem16Segment;
UINT16 Oem16Offset;
UINT16 TpmSegment;
UINT16 TpmOffset;
UINT32 IbvPointer;
UINT32 PciExpressBase;
UINT8 LastPciBus;
} EFI_COMPATIBILITY16_TABLE;
//
// define maximum number of HDD system supports
//
#define MAX_HDD_ENTRIES 0x30
typedef struct {
UINT16 Raw[256];
} ATAPI_IDENTIFY;
//
// HDD_INFO status
//
#define HDD_PRIMARY 0x01
#define HDD_SECONDARY 0x02
#define HDD_MASTER_ATAPI_CDROM 0x04
#define HDD_SLAVE_ATAPI_CDROM 0x08
#define HDD_MASTER_IDE 0x20
#define HDD_SLAVE_IDE 0x40
#define HDD_MASTER_ATAPI_ZIPDISK 0x10
#define HDD_SLAVE_ATAPI_ZIPDISK 0x80
typedef struct {
UINT16 Status;
UINT32 Bus;
UINT32 Device;
UINT32 Function;
UINT16 CommandBaseAddress;
UINT16 ControlBaseAddress;
UINT16 BusMasterAddress;
UINT8 HddIrq;
ATAPI_IDENTIFY IdentifyDrive[2];
} HDD_INFO;
//
// Parties data structures
//
typedef struct {
UINT8 DirectoryServiceValidity : 1;
UINT8 RabcaUsedFlag : 1;
UINT8 ExecuteHddDiagnosticsFlag : 1;
UINT8 Reserved : 5;
} UDC_ATTRIBUTES;
typedef struct {
UDC_ATTRIBUTES Attributes;
UINT8 DeviceNumber;
UINT8 BbsTableEntryNumberForParentDevice;
UINT8 BbsTableEntryNumberForBoot;
UINT8 BbsTableEntryNumberForHddDiag;
UINT8 BeerData[128];
UINT8 ServiceAreaData[64];
} UD_TABLE;
//
// define BBS Device Types
//
#define BBS_FLOPPY 0x01
#define BBS_HARDDISK 0x02
#define BBS_CDROM 0x03
#define BBS_PCMCIA 0x04
#define BBS_USB 0x05
#define BBS_EMBED_NETWORK 0x06
#define BBS_BEV_DEVICE 0x80
#define BBS_UNKNOWN 0xff
typedef struct {
UINT16 OldPosition : 4;
UINT16 Reserved1 : 4;
UINT16 Enabled : 1;
UINT16 Failed : 1;
UINT16 MediaPresent : 2;
UINT16 Reserved2 : 4;
} BBS_STATUS_FLAGS;
#define MAX_BBS_ENTRIES 0x100
//
// BBS_IGNORE_ENTRY is placed in the BootPriority field if the entry is to
// be skipped.
// BBS_UNPRIORITIZED_ENTRY is placed in the BootPriority field before
// priority has been assigned but indicates valid entry.
// BBS_LOWEST_PRIORITY is normally used for removable media with no media
// inserted. This allows the 16-bit CSM to allocate a drive letter to
// the device.
// BBS_DO_NOT_BOOT_FROM is used for devices that the 16-bit CSM is to assign
// a drive letter to but never boot from.
//
// AdditionalIrq??Handler usage is IBV specific. The fields have been added
// for:
// 1. Saving non-BBS card info about IRQs taken by card.
// 2. For BBS compliant cards that hook IRQs in order to have their SETUP
// executed.
//
#define BBS_DO_NOT_BOOT_FROM 0xFFFC
#define BBS_LOWEST_PRIORITY 0xFFFD
#define BBS_UNPRIORITIZED_ENTRY 0xFFFE
#define BBS_IGNORE_ENTRY 0xFFFF
typedef struct {
UINT16 BootPriority;
UINT32 Bus;
UINT32 Device;
UINT32 Function;
UINT8 Class;
UINT8 SubClass;
UINT16 MfgStringOffset;
UINT16 MfgStringSegment;
UINT16 DeviceType;
BBS_STATUS_FLAGS StatusFlags;
UINT16 BootHandlerOffset;
UINT16 BootHandlerSegment;
UINT16 DescStringOffset;
UINT16 DescStringSegment;
UINT32 InitPerReserved;
UINT32 AdditionalIrq13Handler;
UINT32 AdditionalIrq18Handler;
UINT32 AdditionalIrq19Handler;
UINT32 AdditionalIrq40Handler;
UINT8 AssignedDriveNumber;
UINT32 AdditionalIrq41Handler;
UINT32 AdditionalIrq46Handler;
UINT32 IBV1;
UINT32 IBV2;
} BBS_TABLE;
#pragma pack()
typedef
BOOLEAN
(EFIAPI *EFI_LEGACY_BIOS_INT86) (
IN EFI_LEGACY_BIOS_PROTOCOL * This,
IN UINT8 BiosInt,
IN OUT EFI_IA32_REGISTER_SET * Regs
)
/*++
Routine Description:
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.
Arguments:
This - Protocol instance pointer.
BiosInt - Processor interrupt vector to invoke
Reg - Register contexted passed into (and returned) from thunk to
16-bit mode
Returns:
FALSE - Thunk completed, and there were no BIOS errors in the target code.
See Regs for status.
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
)
/*++
Routine Description:
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
Arguments:
This - Protocol instance pointer.
Segment - Segemnt of 16-bit mode call
Offset - Offset of 16-bit mdoe call
Reg - Register contexted passed into (and returned) from thunk to
16-bit mode
Stack - Caller allocated stack used to pass arguments
StackSize - Size of Stack in bytes
Returns:
FALSE - Thunk completed, and there were no BIOS errors in the target code.
See Regs for status.
TRUE - There was a BIOS erro in the target code.
--*/
;
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
)
/*++
Routine Description:
Test to see if a legacy PCI ROM exists for this device. Optionally return
the Legacy ROM instance for this PCI device.
Arguments:
This - Protocol instance pointer.
PciHandle - The PCI PC-AT OPROM from this devices ROM BAR will be loaded
RomImage - Return the legacy PCI ROM for this device
RomSize - Size of ROM Image
Flags - Indicates if ROM found and if PC-AT.
Returns:
EFI_SUCCESS - Legacy Option ROM availible for this device
EFI_UNSUPPORTED - Legacy Option ROM not supported.
--*/
;
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
)
/*++
Routine Description:
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:
Arguments:
This - Protocol instance pointer.
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.
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.
Flags - Return Status if ROM was found and if was Legacy OPROM.
DiskStart - Disk number of first device hooked by the ROM. If DiskStart
is the same as DiskEnd no disked were hooked.
DiskEnd - Disk number of the last device hooked by the ROM.
RomShadowAddress - Shadow address of PC-AT ROM
RomShadowSize - Size of RomShadowAddress in bytes
Returns:
EFI_SUCCESS - Thunk completed, see Regs for status.
EFI_INVALID_PARAMETER - PciHandle not found
--*/
;
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
)
/*++
Routine Description:
Attempt to legacy boot the BootOption. If the EFI contexted has been
compromised this function will not return.
Arguments:
This - Protocol instance pointer.
BootOption - EFI Device Path from BootXXXX variable.
LoadOptionSize - Size of LoadOption in size.
LoadOption - LoadOption from BootXXXX variable
Returns:
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
)
/*++
Routine Description:
Update BDA with current Scroll, Num & Cap lock LEDS
Arguments:
This - Protocol instance pointer.
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
Returns:
EFI_SUCCESS - Removable media not present
--*/
;
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
)
/*++
Routine Description:
Retrieve legacy BBS info and assign boot priority.
Arguments:
This - Protocol instance pointer.
HddCount - Number of HDD_INFO structures
HddInfo - Onboard IDE controller information
BbsCount - Number of BBS_TABLE structures
BbsTable - List BBS entries
Returns:
EFI_SUCCESS - Tables returned
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PREPARE_TO_BOOT_EFI) (
IN EFI_LEGACY_BIOS_PROTOCOL * This,
OUT UINT16 *BbsCount,
OUT BBS_TABLE **BbsTable
)
/*++
Routine Description:
Assign drive number to legacy HDD drives prior to booting an EFI
aware OS so the OS can access drives without an EFI driver.
Arguments:
This - Protocol instance pointer.
BbsCount - Number of BBS_TABLE structures
BbsTable - List BBS entries
Returns:
EFI_SUCCESS - Drive numbers assigned
--*/
;
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
)
/*++
Routine Description:
To boot from an unconventional device like parties and/or execute
HDD diagnostics.
Arguments:
This - Protocol instance pointer.
Attributes - How to interpret the other input parameters
BbsEntry - The 0-based index into the BbsTable for the parent
device.
BeerData - Pointer to the 128 bytes of ram BEER data.
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.
Returns:
EFI_INVALID_PARAMETER if error. Does NOT return if no error.
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_SHADOW_ALL_LEGACY_OPROMS) (
IN EFI_LEGACY_BIOS_PROTOCOL * This
)
/*++
Routine Description:
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.
Arguments:
Returns:
EFI_SUCCESS - OPROMs shadowed
--*/
;
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
)
/*++
Routine Description:
Get a region from the LegacyBios for S3 usage.
Arguments:
This - Protocol instance pointer.
LegacyMemorySize - Size of required region
Region - Region to use.
00 = Either 0xE0000 or 0xF0000 block
Bit0 = 1 0xF0000 block
Bit1 = 1 0xE0000 block
Alignment - Address alignment. Bit mapped. First non-zero
bit from right is alignment.
LegacyMemoryAddress - Region Assigned
Returns:
EFI_SUCCESS - Region assigned
Other - Region not assigned
--*/
;
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
)
/*++
Routine Description:
Get a region from the LegacyBios for Tiano usage. Can only be invoked once.
Arguments:
This - Protocol instance pointer.
LegacyMemorySize - Size of data to copy
LegacyMemoryAddress - Legacy Region destination address
Note: must be in region assigned by
LegacyBiosGetLegacyRegion
LegacyMemorySourceAddress - Source of data
Returns:
EFI_SUCCESS - Region assigned
EFI_ACCESS_DENIED - Destination outside assigned region
--*/
;
typedef 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;
} EFI_LEGACY_BIOS_PROTOCOL;
extern EFI_GUID gEfiLegacyBiosProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyBiosPlatform/LegacyBiosPlatform.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Legacy BIOS Platform Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (LegacyBiosPlatform)
EFI_GUID gEfiLegacyBiosPlatformProtocolGuid = EFI_LEGACY_BIOS_PLATFORM_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiLegacyBiosPlatformProtocolGuid, "Legacy BIOS Platform Protocol", "Legacy BIOS Platform Protocol");

328
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyBiosPlatform/LegacyBiosPlatform.h Normal file
View File

@@ -0,0 +1,328 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
LegacyBiosPlatform.h
Abstract:
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
Revision History
The EFI Legacy BIOS Platform Protocol is compliant with CSM spec 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 \
}
EFI_FORWARD_DECLARATION (EFI_LEGACY_BIOS_PLATFORM_PROTOCOL);
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (LegacyBios)
#pragma pack(1)
//
// Define structures for GetOemIntData
// Note:
// OemIntDataElenent is an array of structures from 0 to Count-1.
// RawData is an array of bytes from 0 to RamDataLength-1.
//
typedef struct {
UINT16 Int;
UINT16 Ax;
UINT32 RawDataLength;
UINT8 RawData[1];
} EFI_OEM_INT_DATA_ELEMENT;
typedef struct {
UINT16 Count;
EFI_OEM_INT_DATA_ELEMENT OemIntDataElement[1];
} EFI_OEM_INT_DATA;
#pragma pack()
typedef enum {
EfiGetPlatformBinaryMpTable = 0,
EfiGetPlatformBinaryOemIntData = 1,
EfiGetPlatformBinaryOem16Data = 2,
EfiGetPlatformBinaryOem32Data = 3,
EfiGetPlatformBinaryTpmBinary = 4,
EfiGetPlatformBinarySystemRom = 5,
EfiGetPlatformPciExpressBase = 6,
EfiGetPlatformPmmSize = 7,
EfiGetPlatformEndOfOpromShadowAddr = 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;
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
)
/*++
Routine Description:
Return a System ROM image for the platform
Arguments:
This - Protocol instance pointer.
Mode - Specifies what data to return
Table - Pointer to MP table.
TableSize - Size in bytes of table.
Location - Legacy region requested
0x00 = Any location
Bit 0 = 0xF0000 region
Bit 1 = 0xE0000 region
Multiple bits can be set
Alignment - Address alignment for allocation.
Bit mapped. First non-zero bit from right
is alignment.
LegacySegment - Segment in LegacyBios where Table is stored
LegacyOffset - Offset in LegacyBios where Table is stored
Returns:
EFI_SUCCESS - Data was returned successfully.
EFI_UNSUPPORTED - Mode is not supported on the platform.
EFI_NOT_FOUND - Binary image or table not found.
--*/
;
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
)
/*++
Routine Description:
Return the Legacy16 policy for which device should be the VGA controller
used during a Legacy16 boot.
Arguments:
This - Protocol instance pointer.
Mode - Specifies what handle to return.
Type - Type from Device Path for Handle to represent.
HandleBuffer - Handles of the device/controller in priority order
with HandleBuffer[0] highest priority.
HandleCount - Number of handles in the buffer.
AdditionalData - Mode specific.
Returns:
EFI_SUCCESS - Handle is valid
EFI_UNSUPPORTED - Mode is not supported on the platform.
EFI_NOT_FOUND - Handle is not known
--*/
;
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_BIOS_PLATFORM_SMM_INIT) (
IN EFI_LEGACY_BIOS_PLATFORM_PROTOCOL * This,
IN VOID *EfiToLegacy16BootTable
);
/*++
Routine Description:
Load and initialize the Legacy BIOS SMM handler.
Arguments:
This - Protocol instance pointer.
EfiToLegacy16BootTable - Pointer to Legacy16 boot table.
Returns:
EFI_SUCCESS - SMM code loaded.
EFI_DEVICE_ERROR - SMM code failed to load
--*/
;
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
)
/*++
Routine Description:
Prepare to scan a ROM.
Arguments:
This - Protocol instance pointer.
Handle - Device handle
ShadowAddress - Address that ROM is shadowed at prior to
initialization or first free ROM address,
depending upon mode.
Compatibility16Table - Pointer to Compatibility16Table.
AdditionalData - Mode specific.
Returns:
EFI_SUCCESS - RomImage is valid
EFI_UNSUPPORTED - Mode is not supported on the platform or platform
policy is to not install this OPROM.
--*/
;
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
)
/*++
Routine Description:
1. List of IRQ routing entries and number of entries.
2. Pointer to Entire $PIR table and length.
3. List of IRQs to assign to PCI in priority.
Arguments:
This - Protocol instance pointer.
RoutingTable - Pointer to PCI IRQ Routing table.
RoutingTableEntries - Number of entries in table.
LocalPirqTable - $PIR table
PirqTableSize - $PIR table size
LocalIrqPriorityTable - List of interrupts in priority order to assign
IrqPriorityTableEntries- Number of entries in priority table
Returns:
EFI_SUCCESS - Table pointer returned
--*/
;
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
)
/*++
Routine Description:
Translate the PIRQ reported by the PCI device into the true PIRQ
from the internal IRQ routing information and IRQ assigned or to be
assigned to device.
Arguments:
This - Protocol instance pointer.
Base as defined below is the bus,device, function in
IRQ routing table.
PciBus - Base Bus for this device.
PciDevice - Base Device for this device.
PciFunction - Base Function for this device.
Pirq - Input is PIRQ reported by device, output is true PIRQ.
PciIrq - The IRQ already assigned to the PIRQ or the IRQ to be
assigned to the PIRQ.
Returns:
EFI_SUCCESS - Irq translated
--*/
;
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
)
/*++
Routine Description:
Attempt to legacy boot the BootOption. If the EFI contexted has been
compromised this function will not return.
Arguments:
This - Protocol instance pointer.
BbsDevicePath - EFI Device Path from BootXXXX variable.
BbsTable - Internal BBS table.
LoadOptionSize - Size of LoadOption in size.
LoadOption - LoadOption from BootXXXX variable
EfiToLegacy16BootTable - Pointer to BootTable structure
Returns:
EFI_SUCCESS - Removable media not present
--*/
;
typedef 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;
} EFI_LEGACY_BIOS_PLATFORM_PROTOCOL;
extern EFI_GUID gEfiLegacyBiosPlatformProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyInterrupt/LegacyInterrupt.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Legacy InterruptProtocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (LegacyInterrupt)
EFI_GUID gEfiLegacyInterruptProtocolGuid = EFI_LEGACY_INTERRUPT_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiLegacyInterruptProtocolGuid, "Legacy Interrupt Protocol", "Legacy Interrupt Protocol");

136
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyInterrupt/LegacyInterrupt.h Normal file
View File

@@ -0,0 +1,136 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
LegacyInterrupt.h
Abstract:
This protocol manages the PIRQ for PCI devices
Revision History
The EFI Legacy Interrupt Protocol is compliant with CSM spec 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 \
}
EFI_FORWARD_DECLARATION (EFI_LEGACY_INTERRUPT_PROTOCOL);
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_GET_NUMBER_PIRQS) (
IN EFI_LEGACY_INTERRUPT_PROTOCOL * This,
OUT UINT8 *NumberPirqs
);
/*++
Routine Description:
Return the number of PIRQs this hardware supports.
Arguments:
This - Protocol instance pointer.
NumberPirsq - Number of PIRQs.
Returns:
EFI_SUCCESS - Number of PIRQs 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
);
/*++
Routine Description:
Return PCI location of this device. $PIR table requires this info.
Arguments:
This - Protocol instance pointer.
Bus - PCI Bus
Device - PCI Device
Function - PCI Function
Returns:
EFI_SUCCESS - Bus/Device/Function returned
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_INTERRUPT_READ_PIRQ) (
IN EFI_LEGACY_INTERRUPT_PROTOCOL * This,
IN UINT8 PirqNumber,
OUT UINT8 *PirqData
);
/*++
Routine Description:
Read the PIRQ register and return the data
Arguments:
This - Protocol instance pointer.
PirqNumber - PIRQ register to read
PirqData - Data read
Returns:
EFI_SUCCESS - Data was read
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
);
/*++
Routine Description:
Write the specified PIRQ register with the given data.
Arguments:
This - Protocol instance pointer.
PirqNumber - PIRQ register to read.
PirqData - Data written.
Returns:
EFI_SUCCESS - Table pointer returned
EFI_INVALID_PARAMETER - Invalid PIRQ number
--*/
typedef 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;
} EFI_LEGACY_INTERRUPT_PROTOCOL;
extern EFI_GUID gEfiLegacyInterruptProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyRegion/LegacyRegion.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Legacy Region Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (LegacyRegion)
EFI_GUID gEfiLegacyRegionProtocolGuid = EFI_LEGACY_REGION_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiLegacyRegionProtocolGuid, "Legacy Region Protocol", "Legacy Region Protocol");

82
EdkCompatibilityPkg/Foundation/Framework/Protocol/LegacyRegion/LegacyRegion.h Normal file
View File

@@ -0,0 +1,82 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
LegacyRegion.h
Abstract:
This protocol manages the legacy memory regions between 0xc0000 - 0xfffff
Revision History
The EFI Legacy Region Protocol is compliant with CSM spec 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 \
}
EFI_FORWARD_DECLARATION (EFI_LEGACY_REGION_PROTOCOL);
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_DECODE) (
IN EFI_LEGACY_REGION_PROTOCOL * This,
IN UINT32 Start,
IN UINT32 Length,
IN BOOLEAN *On
);
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_LOCK) (
IN EFI_LEGACY_REGION_PROTOCOL * This,
IN UINT32 Start,
IN UINT32 Length,
OUT UINT32 *Granularity OPTIONAL
);
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
);
typedef
EFI_STATUS
(EFIAPI *EFI_LEGACY_REGION_UNLOCK) (
IN EFI_LEGACY_REGION_PROTOCOL * This,
IN UINT32 Start,
IN UINT32 Length,
OUT UINT32 *Granularity OPTIONAL
);
typedef 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;
} EFI_LEGACY_REGION_PROTOCOL;
extern EFI_GUID gEfiLegacyRegionProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/PciHostBridgeResourceAllocation/PciHostBridgeResourceAllocation.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (PciHostBridgeResourceAllocation)
EFI_GUID gEfiPciHostBridgeResourceAllocationProtocolGuid = EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GUID;
EFI_GUID_STRING
(
&gEfiPciHostBridgeResourceAllocationProtocolGuid, "PciHostBridgeRresourceAllocation Protocol",
"Pci Host Bridge Resource Allocation Protocol"
);

364
EdkCompatibilityPkg/Foundation/Framework/Protocol/PciHostBridgeResourceAllocation/PciHostBridgeResourceAllocation.h Normal file
View File

@@ -0,0 +1,364 @@
/*++
Copyright (c) 2004, 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
Abstract:
--*/
#ifndef _PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_H_
#define _PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_H_
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION(PciRootBridgeIo)
#define EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GUID \
{ 0xCF8034BE,0x6768,0x4d8b,0xB7,0x39,0x7C,0xCE,0x68,0x3A,0x9F,0xBE }
EFI_FORWARD_DECLARATION (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.
//
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
);
/*++
Routine Description:
Enter a certain phase of the PCI enumeration process
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL instance
Phase -- The phase during enumeration
Returns:
EFI_SUCCESS - Success
EFI_OUT_OF_RESOURCES - If SubmitResources ( ) could not allocate resources
EFI_NOT_READY - This phase cannot be entered at this time
EFI_DEVICE_ERROR - SetResources failed due to HW error.
--*/
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
);
/*++
Routine Description:
Return the device handle of the next PCI root bridge that is associated with
this Host Bridge
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
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
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
--*/
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
);
/*++
Routine Description:
Returns the attributes of a PCI Root Bridge.
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
RootBridgeHandle -- The device handle of the PCI Root Bridge
that the caller is interested in
Attribute -- The pointer to attributes of the PCI Root Bridge
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
EFI_INVALID_PARAMETER - Attributes is NULL
--*/
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
);
/*++
Routine Description:
This is the request from the PCI enumerator to set up
the specified PCI Root Bridge for bus enumeration process.
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
RootBridgeHandle -- The PCI Root Bridge to be set up
Configuration -- Pointer to the pointer to the PCI bus resource descriptor
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
EFI_DEVICE_ERROR - Request failed due to hardware error
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
);
/*++
Routine Description:
This function programs the PCI Root Bridge hardware so that
it decodes the specified PCI bus range
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
RootBridgeHandle -- The PCI Root Bridge whose bus range is to be programmed
Configuration -- The pointer to the PCI bus resource descriptor
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
EFI_INVALID_PARAMETER - Configuration is NULL
EFI_INVALID_PARAMETER - Configuration does not point to a valid ACPI resource descriptor
EFI_INVALID_PARAMETER - Configuration contains one or more memory or IO ACPI resource descriptor
EFI_INVALID_PARAMETER - Address Range Minimum or Address Range Length fields in Configuration
are invalid for this Root Bridge.
EFI_INVALID_PARAMETER - Configuration contains one or more invalid ACPI resource descriptor
EFI_DEVICE_ERROR - Request failed due to hardware error
EFI_OUT_OF_RESOURCES - Request failed due to lack of resources
--*/
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
);
/*++
Routine Description:
Submits the I/O and memory resource requirements for the specified PCI Root Bridge
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
RootBridgeHandle -- The PCI Root Bridge whose I/O and memory resource requirements
are being submitted
Configuration -- The pointer to the PCI I/O and PCI memory resource descriptor
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
EFI_INVALID_PARAMETER - Configuration is NULL
EFI_INVALID_PARAMETER - Configuration does not point to a valid ACPI resource descriptor
EFI_INVALID_PARAMETER - Configuration includes a resource descriptor of unsupported type
--*/
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
);
/*++
Routine Description:
This function returns the proposed resource settings for the specified
PCI Root Bridge
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
RootBridgeHandle -- The PCI Root Bridge handle
Configuration -- The pointer to the pointer to the PCI I/O
and memory resource descriptor
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
EFI_DEVICE_ERROR - Request failed due to hardware error
EFI_OUT_OF_RESOURCES - Request failed due to lack of resources
--*/
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
);
/*++
Routine Description:
This function is called for all the PCI controllers that the PCI
bus driver finds. Can be used to Preprogram the controller.
Arguments:
This -- The EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_ PROTOCOL instance
RootBridgeHandle -- The PCI Root Bridge handle
PciBusAddress -- Address of the controller on the PCI bus
Phase -- The Phase during resource allocation
Returns:
EFI_SUCCESS - Success
EFI_INVALID_PARAMETER - RootBridgeHandle is invalid
EFI_DEVICE_ERROR - Device pre-initialization failed due to hardware error.
--*/
typedef 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;
} EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL;
extern EFI_GUID gEfiPciHostBridgeResourceAllocationProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/PciHotPlugInit/PciHotPlugInit.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
EFI PCI Hot Plug Init Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (PciHotPlugInit)
EFI_GUID gEfiPciHotPlugInitProtocolGuid = EFI_PCI_HOT_PLUG_INIT_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiPciHotPlugInitProtocolGuid, "PCI Hot Plug Init Protocol", "PCI Hot Plug Init Protocol");

97
EdkCompatibilityPkg/Foundation/Framework/Protocol/PciHotPlugInit/PciHotPlugInit.h Normal file
View File

@@ -0,0 +1,97 @@
/*++
Copyright (c) 2004, 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
Abstract:
EFI PCI Hot Plug Init Protocol
Revision History
--*/
#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 }
EFI_FORWARD_DECLARATION (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;
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
);
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
);
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
//
typedef 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;
} EFI_PCI_HOT_PLUG_INIT_PROTOCOL;
extern EFI_GUID gEfiPciHotPlugInitProtocolGuid;
#endif

26
EdkCompatibilityPkg/Foundation/Framework/Protocol/PciPlatform/PciPlatform.c Normal file
View File

@@ -0,0 +1,26 @@
/*++
Copyright (c) 2004, 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.c
Abstract:
This file defines global GUID variables for PlatformOpRom protocols.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_PRODUCER (PciPlatform)
EFI_GUID gEfiPciPlatformProtocolGuid = EFI_PCI_PLATFORM_PROTOCOL_GUID;
EFI_GUID_STRING (&gEfiPciPlatformProtocolGuid, "Pci Platform Protocol", "Pci Platform Protocol");

211
EdkCompatibilityPkg/Foundation/Framework/Protocol/PciPlatform/PciPlatform.h Normal file
View File

@@ -0,0 +1,211 @@
/*++
Copyright (c) 2004, 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
Abstract:
This file declares PlatfromOpRom protocols.
--*/
#ifndef _PCI_PLATFORM_H_
#define _PCI_PLATFORM_H_
#include "Tiano.h"
#include "TianoTypes.h"
#include EFI_PROTOCOL_DEFINITION (PciHostBridgeResourceAllocation)
#include EFI_PROTOCOL_DEFINITION (PciRootBridgeIo)
//
// Protocol for GUID.
//
#define EFI_PCI_PLATFORM_PROTOCOL_GUID \
{ 0x7d75280, 0x27d4, 0x4d69, 0x90, 0xd0, 0x56, 0x43, 0xe2, 0x38, 0xb3, 0x41}
EFI_FORWARD_DECLARATION (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;
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
)
/*++
Routine Description:
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.
Arguments:
This - Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
HostBridge - The handle of the host bridge controller.
Phase - The phase of the PCI bus enumeration.
ChipsetPhase - Defines the execution phase of the PCI chipset driver.
Returns:
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
)
/*++
Routine Description:
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.
Arguments:
This - Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
HostBridge - The associated PCI host bridge handle.
RootBridge - The associated PCI root bridge handle.
PciAddress - The address of the PCI device on the PCI bus.
Phase - The phase of the PCI controller enumeration.
ChipsetPhase - Defines the execution phase of the PCI chipset driver.
Returns:
EFI_SUCCESS - The function completed successfully.
--*/
;
typedef
EFI_STATUS
(EFIAPI * EFI_PCI_PLATFORM_GET_PLATFORM_POLICY) (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
OUT EFI_PCI_PLATFORM_POLICY *PciPolicy
)
/*++
Routine Description:
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.
Arguments:
This - Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
PciPolicy - The platform policy with respect to VGA and ISA aliasing.
Returns:
EFI_SUCCESS - The function completed successfully.
EFI_INVALID_PARAMETER - PciPolicy is NULL.
--*/
;
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
)
/*++
Routine Description:
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.
Arguments:
This - Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
PciHandle - The handle of the PCI device.
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.
RomSize - If the call succeeds, a pointer to the size of the option ROM size. Otherwise,
this field is undefined.
Returns:
EFI_SUCCESS - The option ROM was available for this device and loaded into memory.
EFI_NOT_FOUND - No option ROM was available for this device.
EFI_OUT_OF_RESOURCES - No memory was available to load the option ROM.
EFI_DEVICE_ERROR - An error occurred in getting the option ROM.
--*/
;
typedef 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;
} EFI_PCI_PLATFORM_PROTOCOL;
extern EFI_GUID gEfiPciPlatformProtocolGuid;
#endif

28
EdkCompatibilityPkg/Foundation/Framework/Protocol/SectionExtraction/SectionExtraction.c Normal file
View File

@@ -0,0 +1,28 @@
/*++
Copyright (c) 2004, 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:
SectionExtraction.c
Abstract:
Section Extraction protocol as defined in the Tiano File Image Format
specification.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SectionExtraction)
EFI_GUID gEfiSectionExtractionProtocolGuid = EFI_SECTION_EXTRACTION_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSectionExtractionProtocolGuid, "Section Extraction Protocol", "Tiano Section Extraction Protocol");

83
EdkCompatibilityPkg/Foundation/Framework/Protocol/SectionExtraction/SectionExtraction.h Normal file
View File

@@ -0,0 +1,83 @@
/*++
Copyright (c) 2004, 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:
SectionExtraction.h
Abstract:
Section extraction protocol as defined in the Tiano File Image Format specification.
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.
--*/
#ifndef _SECTION_EXTRACTION_PROTOCOL_H
#define _SECTION_EXTRACTION_PROTOCOL_H
#include "EfiFirmwareFileSystem.h"
//
// Protocol GUID definition
//
#define EFI_SECTION_EXTRACTION_PROTOCOL_GUID \
{ \
0x448F5DA4, 0x6DD7, 0x4FE1, 0x93, 0x07, 0x69, 0x22, 0x41, 0x92, 0x21, 0x5D \
}
EFI_FORWARD_DECLARATION (EFI_SECTION_EXTRACTION_PROTOCOL);
//
// Protocol member functions
//
typedef
EFI_STATUS
(EFIAPI *EFI_OPEN_SECTION_STREAM) (
IN EFI_SECTION_EXTRACTION_PROTOCOL * This,
IN UINTN SectionStreamLength,
IN VOID *SectionStream,
OUT UINTN *SectionStreamHandle
);
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
);
typedef
EFI_STATUS
(EFIAPI *EFI_CLOSE_SECTION_STREAM) (
IN EFI_SECTION_EXTRACTION_PROTOCOL * This,
IN UINTN SectionStreamHandle
);
//
// Protocol definition
//
typedef struct _EFI_SECTION_EXTRACTION_PROTOCOL {
EFI_OPEN_SECTION_STREAM OpenSectionStream;
EFI_GET_SECTION GetSection;
EFI_CLOSE_SECTION_STREAM CloseSectionStream;
} EFI_SECTION_EXTRACTION_PROTOCOL;
extern EFI_GUID gEfiSectionExtractionProtocolGuid;
#endif

28
EdkCompatibilityPkg/Foundation/Framework/Protocol/SecurityPolicy/SecurityPolicy.c Normal file
View File

@@ -0,0 +1,28 @@
/*++
Copyright (c) 2004, 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:
SecurityPolicy.c
Abstract:
Security Policy protocol as defined in the DXE CIS
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SecurityPolicy)
EFI_GUID gEfiSecurityPolicyProtocolGuid = EFI_SECURITY_POLICY_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSecurityPolicyProtocolGuid, "Security Policy protocol", "Security Policy protocol");

33
EdkCompatibilityPkg/Foundation/Framework/Protocol/SecurityPolicy/SecurityPolicy.h Normal file
View File

@@ -0,0 +1,33 @@
/*++
Copyright (c) 2004, 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:
SecurityPolicy.h
Abstract:
Security Policy protocol as defined in the DXE CIS
--*/
#ifndef _SECURITY_POLICY_H_
#define _SECURITY_POLICY_H_
//
// Security policy protocol GUID definition
//
#define EFI_SECURITY_POLICY_PROTOCOL_GUID \
{0x78E4D245, 0xCD4D, 0x4a05, 0xA2, 0xBA, 0x47, 0x43, 0xE8, 0x6C, 0xFC, 0xAB}
extern EFI_GUID gEfiSecurityPolicyProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/Smbus/Smbus.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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:
SmBus.c
Abstract:
EFI SMBUS Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (Smbus)
EFI_GUID gEfiSmbusProtocolGuid = EFI_SMBUS_HC_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmbusProtocolGuid, "SMBUS Protocol", "EFI 2.0 SMBUS Protocol");

93
EdkCompatibilityPkg/Foundation/Framework/Protocol/Smbus/Smbus.h Normal file
View File

@@ -0,0 +1,93 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Smbus.h
Abstract:
EFI SMBUS Protocol
--*/
#ifndef _EFI_SMBUS_H
#define _EFI_SMBUS_H
#include "EfiSmbus.h"
#define EFI_SMBUS_HC_PROTOCOL_GUID \
{ \
0xe49d33ed, 0x513d, 0x4634, 0xb6, 0x98, 0x6f, 0x55, 0xaa, 0x75, 0x1c, 0x1b \
}
EFI_FORWARD_DECLARATION (EFI_SMBUS_HC_PROTOCOL);
typedef
EFI_STATUS
(EFIAPI *EFI_SMBUS_HC_EXECUTE_OPERATION) (
IN EFI_SMBUS_HC_PROTOCOL * This,
IN EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
IN EFI_SMBUS_DEVICE_COMMAND Command,
IN EFI_SMBUS_OPERATION Operation,
IN BOOLEAN PecCheck,
IN OUT UINTN *Length,
IN OUT VOID *Buffer
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMBUS_NOTIFY_FUNCTION) (
IN EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
IN UINTN Data
);
//
// If ArpAll is TRUE, SmbusUdid/SlaveAddress is Optional.
// If FALSE, ArpDevice will enum SmbusUdid and the address will be at SlaveAddress
//
typedef
EFI_STATUS
(EFIAPI *EFI_SMBUS_HC_PROTOCOL_ARP_DEVICE) (
IN EFI_SMBUS_HC_PROTOCOL * This,
IN BOOLEAN ArpAll,
IN EFI_SMBUS_UDID * SmbusUdid, OPTIONAL
IN OUT EFI_SMBUS_DEVICE_ADDRESS * SlaveAddress OPTIONAL
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMBUS_HC_PROTOCOL_GET_ARP_MAP) (
IN EFI_SMBUS_HC_PROTOCOL * This,
IN OUT UINTN *Length,
IN OUT EFI_SMBUS_DEVICE_MAP **SmbusDeviceMap
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMBUS_HC_PROTOCOL_NOTIFY) (
IN EFI_SMBUS_HC_PROTOCOL * This,
IN EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
IN UINTN Data,
IN EFI_SMBUS_NOTIFY_FUNCTION NotifyFunction
);
typedef struct _EFI_SMBUS_HC_PROTOCOL {
EFI_SMBUS_HC_EXECUTE_OPERATION Execute;
EFI_SMBUS_HC_PROTOCOL_ARP_DEVICE ArpDevice;
EFI_SMBUS_HC_PROTOCOL_GET_ARP_MAP GetArpMap;
EFI_SMBUS_HC_PROTOCOL_NOTIFY Notify;
} EFI_SMBUS_HC_PROTOCOL;
extern EFI_GUID gEfiSmbusProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmAccess/SmmAccess.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
This file defines SMM SMRAM abstraction protocol defined by the
SMM Component Interface Specification
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmAccess)
EFI_GUID gEfiSmmAccessProtocolGuid = EFI_SMM_ACCESS_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmmAccessProtocolGuid, "SMM Access Protocol", "SMM Access protocol");

79
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmAccess/SmmAccess.h Normal file
View File

@@ -0,0 +1,79 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
SmmAccess.h
Abstract:
This file defines SMM SMRAM Access abstraction protocol defined
by the SMM CIS.
--*/
#ifndef _SMM_ACCESS_H_
#define _SMM_ACCESS_H_
#include EFI_GUID_DEFINITION (SmramMemoryReserve)
EFI_FORWARD_DECLARATION (EFI_SMM_ACCESS_PROTOCOL);
#define EFI_SMM_ACCESS_PROTOCOL_GUID \
{ \
0x3792095a, 0xe309, 0x4c1e, 0xaa, 0x01, 0x85, 0xf5, 0x65, 0x5a, 0x17, 0xf1 \
}
//
// SMM Access specification Data Structures
//
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_OPEN) (
IN EFI_SMM_ACCESS_PROTOCOL * This,
UINTN DescriptorIndex
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CLOSE) (
IN EFI_SMM_ACCESS_PROTOCOL * This,
UINTN DescriptorIndex
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_LOCK) (
IN EFI_SMM_ACCESS_PROTOCOL * This,
UINTN DescriptorIndex
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_CAPABILITIES) (
IN EFI_SMM_ACCESS_PROTOCOL * This,
IN OUT UINTN *SmramMapSize,
IN OUT EFI_SMRAM_DESCRIPTOR * SmramMap
);
typedef 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;
} EFI_SMM_ACCESS_PROTOCOL;
extern EFI_GUID gEfiSmmAccessProtocolGuid;
#endif

38
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmBase/SmmBase.c Normal file
View File

@@ -0,0 +1,38 @@
/*++
Copyright (c) 1999 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
SmmBase.c
Abstract:
This file defines SMM Base abstraction protocol defined by the
SMM Component Interface Specification
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmBase)
EFI_GUID gEfiSmmBaseProtocolGuid = EFI_SMM_BASE_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmmBaseProtocolGuid, "SMM Base Protocol", "SMM Base protocol");
EFI_GUID gEfiSmmCpuIoGuid = EFI_SMM_CPU_IO_GUID;
EFI_GUID_STRING(&gEfiSmmCpuIoGuid, "SMM CPU IO", "SMM CPU IO");
EFI_GUID gEfiSmmCommunicateHeaderGuid = SMM_COMMUNICATE_HEADER_GUID;
EFI_GUID_STRING(&gEfiSmmCommunicateHeaderGuid, "SMM Communicate Header Guid", "SMM Communicate Header Guid");

797
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmBase/SmmBase.h Normal file
View File

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

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmControl/SmmControl.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
This file defines SMM Control abstraction protocol defined by the
SMM Component Interface Specification
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmControl)
EFI_GUID gEfiSmmControlProtocolGuid = EFI_SMM_CONTROL_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmmControlProtocolGuid, "SMM Control Protocol", "SMM Control protocol");

79
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmControl/SmmControl.h Normal file
View File

@@ -0,0 +1,79 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
This file defines SMM Control abstraction protocol defined
by the SMM CIS.
--*/
#ifndef _SMM_CONTROL_H_
#define _SMM_CONTROL_H_
EFI_FORWARD_DECLARATION (EFI_SMM_CONTROL_PROTOCOL);
#define EFI_SMM_CONTROL_PROTOCOL_GUID \
{ \
0x8d12e231, 0xc667, 0x4fd1, 0x98, 0xf2, 0x24, 0x49, 0xa7, 0xe7, 0xb2, 0xe5 \
}
//
// SMM Control specification constant and types
//
// typedef EFI_SMM_PERIOD UINTN
//
// SMM Access specification Data Structures
//
typedef struct {
UINT8 SmiTriggerRegister;
UINT8 SmiDataRegister;
} EFI_SMM_CONTROL_REGISTER;
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
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_DEACTIVATE) (
IN EFI_SMM_CONTROL_PROTOCOL * This,
IN BOOLEAN Periodic OPTIONAL
);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GET_REGISTER_INFO) (
IN EFI_SMM_CONTROL_PROTOCOL * This,
IN OUT EFI_SMM_CONTROL_REGISTER * SmiRegister
);
typedef struct _EFI_SMM_CONTROL_PROTOCOL {
EFI_SMM_ACTIVATE Trigger;
EFI_SMM_DEACTIVATE Clear;
EFI_SMM_GET_REGISTER_INFO GetRegisterInfo;
UINTN MinimumTriggerPeriod;
} EFI_SMM_CONTROL_PROTOCOL;
extern EFI_GUID gEfiSmmControlProtocolGuid;
#endif

150
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmCpuState/CpuSaveState.h Normal file
View File

@@ -0,0 +1,150 @@
/*++
Copyright (c) 2005, 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:
CpuSaveState.h
Abstract:
Define data structures used by EFI_SMM_CPU_SAVE_STATE protocol.
Revision History
++*/
#ifndef _CPUSAVESTATE_H_
#define _CPUSAVESTATE_H_
typedef unsigned char ASM_UINT8;
typedef ASM_UINT8 ASM_BOOL;
typedef unsigned short ASM_UINT16;
typedef unsigned long ASM_UINT32;
#ifdef _H2INC
typedef double ASM_UINT64;
#else
typedef unsigned __int64 ASM_UINT64;
#endif
#pragma pack (push)
#pragma pack (1)
typedef struct _EFI_SMM_CPU_STATE32 {
ASM_UINT8 Reserved1[0xf8]; // fe00h
ASM_UINT32 SMBASE; // fef8h
ASM_UINT32 SMMRevId; // fefch
ASM_UINT16 IORestart; // ff00h
ASM_UINT16 AutoHALTRestart; // ff02h
ASM_UINT32 IEDBASE; // ff04h
ASM_UINT8 Reserved2[0x98]; // ff08h
ASM_UINT32 IOMemAddr; // ffa0h
ASM_UINT32 IOMisc; // ffa4h
ASM_UINT32 _ES;
ASM_UINT32 _CS;
ASM_UINT32 _SS;
ASM_UINT32 _DS;
ASM_UINT32 _FS;
ASM_UINT32 _GS;
ASM_UINT32 _LDTBase;
ASM_UINT32 _TR;
ASM_UINT32 _DR7;
ASM_UINT32 _DR6;
ASM_UINT32 _EAX;
ASM_UINT32 _ECX;
ASM_UINT32 _EDX;
ASM_UINT32 _EBX;
ASM_UINT32 _ESP;
ASM_UINT32 _EBP;
ASM_UINT32 _ESI;
ASM_UINT32 _EDI;
ASM_UINT32 _EIP;
ASM_UINT32 _EFLAGS;
ASM_UINT32 _CR3;
ASM_UINT32 _CR0;
} EFI_SMM_CPU_STATE32;
typedef struct _EFI_SMM_CPU_STATE64 {
ASM_UINT8 Reserved1[0x1d0]; // fc00h
ASM_UINT32 GdtBaseHiDword; // fdd0h
ASM_UINT32 LdtBaseHiDword; // fdd4h
ASM_UINT32 IdtBaseHiDword; // fdd8h
ASM_UINT8 Reserved2[0xc]; // fddch
ASM_UINT64 IO_EIP; // fde8h
ASM_UINT8 Reserved3[0x50]; // fdf0h
ASM_UINT32 _CR4; // fe40h
ASM_UINT8 Reserved4[0x48]; // fe44h
ASM_UINT32 GdtBaseLoDword; // fe8ch
ASM_UINT32 GdtLimit; // fe90h
ASM_UINT32 IdtBaseLoDword; // fe94h
ASM_UINT32 IdtLimit; // fe98h
ASM_UINT32 LdtBaseLoDword; // fe9ch
ASM_UINT32 LdtLimit; // fea0h
ASM_UINT32 LdtInfo; // fea4h
ASM_UINT8 Reserved5[0x50]; // fea8h
ASM_UINT32 SMBASE; // fef8h
ASM_UINT32 SMMRevId; // fefch
ASM_UINT16 IORestart; // ff00h
ASM_UINT16 AutoHALTRestart; // ff02h
ASM_UINT32 IEDBASE; // ff04h
ASM_UINT8 Reserved6[0x14]; // ff08h
ASM_UINT64 _R15; // ff1ch
ASM_UINT64 _R14;
ASM_UINT64 _R13;
ASM_UINT64 _R12;
ASM_UINT64 _R11;
ASM_UINT64 _R10;
ASM_UINT64 _R9;
ASM_UINT64 _R8;
ASM_UINT64 _RAX; // ff5ch
ASM_UINT64 _RCX;
ASM_UINT64 _RDX;
ASM_UINT64 _RBX;
ASM_UINT64 _RSP;
ASM_UINT64 _RBP;
ASM_UINT64 _RSI;
ASM_UINT64 _RDI;
ASM_UINT64 IOMemAddr; // ff9ch
ASM_UINT32 IOMisc; // ffa4h
ASM_UINT32 _ES; // ffa8h
ASM_UINT32 _CS;
ASM_UINT32 _SS;
ASM_UINT32 _DS;
ASM_UINT32 _FS;
ASM_UINT32 _GS;
ASM_UINT32 _LDTR; // ffc0h
ASM_UINT32 _TR;
ASM_UINT64 _DR7; // ffc8h
ASM_UINT64 _DR6;
ASM_UINT64 _RIP; // ffd8h
ASM_UINT64 IA32_EFER; // ffe0h
ASM_UINT64 _RFLAGS; // ffe8h
ASM_UINT64 _CR3; // fff0h
ASM_UINT64 _CR0; // fff8h
} EFI_SMM_CPU_STATE64;
#pragma warning (push)
#pragma warning (disable: 4201)
typedef union _EFI_SMM_CPU_STATE {
struct {
ASM_UINT8 Reserved[0x200];
EFI_SMM_CPU_STATE32 x86;
};
EFI_SMM_CPU_STATE64 x64;
} EFI_SMM_CPU_STATE;
#pragma warning (pop)
#pragma pack (pop)
#define EFI_SMM_MIN_REV_ID_x64 0x30006
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmCpuState/SmmCpuState.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 2005, 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:
SmmCpuState.c
Abstract:
Protocol definition for EFI_SMM_CPU_SAVE_STATE protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmCpuState)
EFI_GUID gEfiSmmCpuSaveStateProtocolGuid = EFI_SMM_CPU_SAVE_STATE_PROTOCOL_GUID;
EFI_GUID_STRING (&gEfiSmmCpuSaveStateProtocolGuid, "SMM CPU Save State Protocol", "SMM CPU Save State Protocol");

43
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmCpuState/SmmCpuState.h Normal file
View File

@@ -0,0 +1,43 @@
/*++
Copyright (c) 2005, 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:
SmmCpuState.h
Abstract:
Protocol definition for EFI_SMM_CPU_SAVE_STATE protocol
Revision History
--*/
#ifndef _SMMSAVESTATE_H_
#define _SMMSAVESTATE_H_
#include "CpuSaveState.h"
//
// Global ID for the Sx SMI Protocol
//
// {21F302AD-6E94-471b-84BC-B14800403A1D}
#define EFI_SMM_CPU_SAVE_STATE_PROTOCOL_GUID \
{ 0x21f302ad, 0x6e94, 0x471b, 0x84, 0xbc, 0xb1, 0x48, 0x0, 0x40, 0x3a, 0x1d }
typedef struct _EFI_SMM_CPU_SAVE_STATE_PROTOCOL {
EFI_SMM_CPU_STATE **CpuSaveState;
} EFI_SMM_CPU_SAVE_STATE_PROTOCOL;
extern EFI_GUID gEfiSmmCpuSaveStateProtocolGuid;
#endif // _SMMSAVESTATE_H_

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmGpiDispatch/SmmGpiDispatch.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm Gpi Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmGpiDispatch)
EFI_GUID gEfiSmmGpiDispatchProtocolGuid = EFI_SMM_GPI_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING
(&gEfiSmmGpiDispatchProtocolGuid, "SMM GPI SMI Dispatch Protocol", "EFI 2.0 SMM GPI SMI Dispatch Protocol");

152
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmGpiDispatch/SmmGpiDispatch.h Normal file
View File

@@ -0,0 +1,152 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
EFI Smm Gpi Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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
//
typedef
VOID
(EFIAPI *EFI_SMM_GPI_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_GPI_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a GPI SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
DispatchContext - Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The GPI input value
is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_GPI_UNREGISTER) (
IN EFI_SMM_GPI_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM GPI SMI Dispatch Protocol
//
typedef struct _EFI_SMM_GPI_DISPATCH_PROTOCOL {
EFI_SMM_GPI_REGISTER Register;
EFI_SMM_GPI_UNREGISTER UnRegister;
UINTN NumSupportedGpis;
} EFI_SMM_GPI_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmGpiDispatchProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmIchnDispatch/SmmIchnDispatch.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm ICH N Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmIchnDispatch)
EFI_GUID gEfiSmmIchnDispatchProtocolGuid = EFI_SMM_ICHN_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING
(&gEfiSmmIchnDispatchProtocolGuid, "SMM ICHn SMI Dispatch Protocol", "EFI 2.0 SMM ICHn SMI Dispatch Protocol");

204
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmIchnDispatch/SmmIchnDispatch.h Normal file
View File

@@ -0,0 +1,204 @@
/*++
Copyright (c) 1999 - 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
Abstract:
EFI Smm ICH [N] Specific Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (EFI_SMM_ICHN_DISPATCH_PROTOCOL);
//
// Related Definitions
//
//
// ICHN Specific SMIs. These are miscellaneous SMI sources that are supported by the
// ICHN specific SMI implementation. These may change over time. TrapNumber is only
// valid if the Type is Trap.
//
typedef enum {
//
// NOTE: NEVER delete items from this list/enumeration! Doing so will prevent other versions
// of the code from compiling. If the ICH version your driver is written for doesn't support
// some of these SMIs, then simply return EFI_UNSUPPORTED when a child/client tries to register
// for them.
//
IchnMch,
IchnPme,
IchnRtcAlarm,
IchnRingIndicate,
IchnAc97Wake,
IchnSerialIrq,
IchnY2KRollover,
IchnTcoTimeout,
IchnOsTco,
IchnNmi,
IchnIntruderDetect,
IchnBiosWp,
IchnMcSmi,
IchnPmeB0,
IchnThrmSts,
IchnSmBus,
IchnIntelUsb2,
IchnMonSmi7,
IchnMonSmi6,
IchnMonSmi5,
IchnMonSmi4,
IchnDevTrap13,
IchnDevTrap12,
IchnDevTrap11,
IchnDevTrap10,
IchnDevTrap9,
IchnDevTrap8,
IchnDevTrap7,
IchnDevTrap6,
IchnDevTrap5,
IchnDevTrap3,
IchnDevTrap2,
IchnDevTrap1,
IchnDevTrap0,
IchnIoTrap3,
IchnIoTrap2,
IchnIoTrap1,
IchnIoTrap0,
IchnPciExpress,
IchnMonitor,
IchnSpi,
IchnQRT,
IchnGpioUnlock,
//
// INSERT NEW ITEMS JUST BEFORE THIS LINE
//
NUM_ICHN_TYPES // the number of items in this enumeration
} EFI_SMM_ICHN_SMI_TYPE;
typedef struct {
EFI_SMM_ICHN_SMI_TYPE Type;
} EFI_SMM_ICHN_DISPATCH_CONTEXT;
//
// Member functions
//
typedef
VOID
(EFIAPI *EFI_SMM_ICHN_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_ICHN_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a ICH n specific SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
DispatchContext - Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The ICHN input value
is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_ICHN_UNREGISTER) (
IN EFI_SMM_ICHN_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM Ich n specific SMI Dispatch Protocol
//
typedef struct _EFI_SMM_ICHN_DISPATCH_PROTOCOL {
EFI_SMM_ICHN_REGISTER Register;
EFI_SMM_ICHN_UNREGISTER UnRegister;
} EFI_SMM_ICHN_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmIchnDispatchProtocolGuid;
#endif

34
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmPeriodicTimerDispatch/SmmPeriodicTimerDispatch.c Normal file
View File

@@ -0,0 +1,34 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm Periodic Timer Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmPeriodicTimerDispatch)
EFI_GUID gEfiSmmPeriodicTimerDispatchProtocolGuid = EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING
(
&gEfiSmmPeriodicTimerDispatchProtocolGuid, "SMM Periodic Timer SMI Dispatch Protocol",
"EFI 2.0 SMM Periodic Timer SMI Dispatch Protocol"
);

205
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmPeriodicTimerDispatch/SmmPeriodicTimerDispatch.h Normal file
View File

@@ -0,0 +1,205 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
EFI Smm Periodic Timer Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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
//
typedef
VOID
(EFIAPI *EFI_SMM_PERIODIC_TIMER_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a Periodic Timer SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
DispatchContext - Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Returns:
Nothing
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_PERIODIC_TIMER_INTERVAL) (
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL * This,
IN OUT UINT64 **SmiTickInterval
);
/*++
Routine Description:
Returns the next SMI tick period supported by the chipset. The order
returned is from longest to shortest interval period.
Arguments:
This - Protocol instance pointer.
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.
Returns:
EFI_SUCCESS
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The period input value
is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_PERIODIC_TIMER_UNREGISTER) (
IN EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM Periodic Timer Dispatch Protocol
//
typedef 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;
} EFI_SMM_PERIODIC_TIMER_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmPeriodicTimerDispatchProtocolGuid;
#endif

34
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmPowerButtonDispatch/SmmPowerButtonDispatch.c Normal file
View File

@@ -0,0 +1,34 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm Power Button Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmPowerButtonDispatch)
EFI_GUID gEfiSmmPowerButtonDispatchProtocolGuid = EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING
(
&gEfiSmmPowerButtonDispatchProtocolGuid, "SMM Power Button SMI Dispatch Protocol",
"EFI 2.0 SMM Power Button SMI Dispatch Protocol"
);

153
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmPowerButtonDispatch/SmmPowerButtonDispatch.h Normal file
View File

@@ -0,0 +1,153 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
EFI Smm Power Button Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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
//
typedef
VOID
(EFIAPI *EFI_SMM_POWER_BUTTON_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a Power Button SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
DispatchContext - Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The Power Button SMI
phase is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_POWER_BUTTON_UNREGISTER) (
IN EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM Power Button SMI Dispatch Protocol
//
typedef struct _EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL {
EFI_SMM_POWER_BUTTON_REGISTER Register;
EFI_SMM_POWER_BUTTON_UNREGISTER UnRegister;
} EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmPowerButtonDispatchProtocolGuid;
#endif

34
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmStandbyButtonDispatch/SmmStandbyButtonDispatch.c Normal file
View File

@@ -0,0 +1,34 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm Standby Button Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmStandbyButtonDispatch)
EFI_GUID gEfiSmmStandbyButtonDispatchProtocolGuid = EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING
(
&gEfiSmmStandbyButtonDispatchProtocolGuid, "SMM Standby Button SMI Dispatch Protocol",
"EFI 2.0 SMM Standby Button SMI Dispatch Protocol"
);

153
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmStandbyButtonDispatch/SmmStandbyButtonDispatch.h Normal file
View File

@@ -0,0 +1,153 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
EFI Smm Standby Button Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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 {
Entry,
Exit
} EFI_STANDBY_BUTTON_PHASE;
typedef struct {
EFI_STANDBY_BUTTON_PHASE Phase;
} EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT;
//
// Member functions
//
typedef
VOID
(EFIAPI *EFI_SMM_STANDBY_BUTTON_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a Standby Button SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
DispatchContext - Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The Standby Button SMI
phase is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_STANDBY_BUTTON_UNREGISTER) (
IN EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM Standby Button SMI Dispatch Protocol
//
typedef struct _EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL {
EFI_SMM_STANDBY_BUTTON_REGISTER Register;
EFI_SMM_STANDBY_BUTTON_UNREGISTER UnRegister;
} EFI_SMM_STANDBY_BUTTON_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmStandbyButtonDispatchProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmStatusCode/SmmStatusCode.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 1999 - 2002, 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:
SmmStatusCode.c
Abstract:
SMM Status code Protocol as defined in EFI 2.0 (for Status Code Architectural Protocol)
This code abstracts Status Code reporting.
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmStatusCode)
EFI_GUID gEfiSmmStatusCodeProtocolGuid = EFI_SMM_STATUS_CODE_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmmStatusCodeProtocolGuid, "SMM Status Code", "SMM Status Code Protocol");

58
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmStatusCode/SmmStatusCode.h Normal file
View File

@@ -0,0 +1,58 @@
/*++
Copyright (c) 1999 - 2002, 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:
SmmStatusCode.h
Abstract:
SMM Status code Protocol as defined in the DXE CIS (Status Code Architectural Protocol)
This code abstracts SMM Status Code reporting.
--*/
#ifndef _PROTOCOL_SMM_STATUS_CODE_H__
#define _PROTOCOL_SMM_STATUS_CODE_H__
//
// Global ID for the Smm Status Code Protocol
//
#define EFI_SMM_STATUS_CODE_PROTOCOL_GUID \
{ \
0x6afd2b77, 0x98c1, 0x4acd, 0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1 \
}
extern EFI_GUID gEfiSmmStatusCodeProtocolGuid;
//
// Forward reference for pure ANSI compatability
//
EFI_FORWARD_DECLARATION (EFI_SMM_STATUS_CODE_PROTOCOL);
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_REPORT_STATUS_CODE) (
IN EFI_SMM_STATUS_CODE_PROTOCOL * This,
IN EFI_STATUS_CODE_TYPE CodeType,
IN EFI_STATUS_CODE_VALUE Value,
IN UINT32 Instance,
IN EFI_GUID * CallerId,
IN EFI_STATUS_CODE_DATA * Data OPTIONAL
);
typedef struct _EFI_SMM_STATUS_CODE_PROTOCOL {
EFI_SMM_REPORT_STATUS_CODE ReportStatusCode;
} EFI_SMM_STATUS_CODE_PROTOCOL;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmSwDispatch/SmmSwDispatch.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm Software Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmSwDispatch)
EFI_GUID gEfiSmmSwDispatchProtocolGuid = EFI_SMM_SW_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmmSwDispatchProtocolGuid, "SMM Sw SMI Dispatch Protocol", "EFI 2.0 SMM Sw SMI Dispatch Protocol");

151
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmSwDispatch/SmmSwDispatch.h Normal file
View File

@@ -0,0 +1,151 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
SmmSwDispatch.h
Abstract:
EFI Smm Software Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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
//
typedef
VOID
(EFIAPI *EFI_SMM_SW_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_SW_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a Software SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
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.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The SW driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The SW SMI input value
is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SW_UNREGISTER) (
IN EFI_SMM_SW_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM Software SMI Dispatch Protocol
//
typedef struct _EFI_SMM_SW_DISPATCH_PROTOCOL {
EFI_SMM_SW_REGISTER Register;
EFI_SMM_SW_UNREGISTER UnRegister;
UINTN MaximumSwiValue;
} EFI_SMM_SW_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmSwDispatchProtocolGuid;
#endif

30
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmSxDispatch/SmmSxDispatch.c Normal file
View File

@@ -0,0 +1,30 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm Sx Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmSxDispatch)
EFI_GUID gEfiSmmSxDispatchProtocolGuid = EFI_SMM_SX_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING(&gEfiSmmSxDispatchProtocolGuid, "SMM Sx Dispatch Protocol", "EFI 2.0 SMM Sx Dispatch Protocol");

170
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmSxDispatch/SmmSxDispatch.h Normal file
View File

@@ -0,0 +1,170 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
EFI Smm Sx Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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
//
typedef
VOID
(EFIAPI *EFI_SMM_SX_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_SX_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a Sx state SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
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 intertace, 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 the Dispatch context and act
accordingly.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_UNSUPPORTED - The Sx driver or hardware does not support that
Sx Type/Phase.
EFI_DEVICE_ERROR - The Sx driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. Type & Phase are not
within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_SX_UNREGISTER) (
IN EFI_SMM_SX_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM Child Dispatch Protocol
//
typedef struct _EFI_SMM_SX_DISPATCH_PROTOCOL {
EFI_SMM_SX_REGISTER Register;
EFI_SMM_SX_UNREGISTER UnRegister;
} EFI_SMM_SX_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmSxDispatchProtocolGuid;
#endif

31
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmUsbDispatch/SmmUsbDispatch.c Normal file
View File

@@ -0,0 +1,31 @@
/*++
Copyright (c) 1999 - 2002, 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.c
Abstract:
EFI Smm USB Smi Child Protocol
Revision History
--*/
#include "Tiano.h"
#include EFI_PROTOCOL_DEFINITION (SmmUsbDispatch)
EFI_GUID gEfiSmmUsbDispatchProtocolGuid = EFI_SMM_USB_DISPATCH_PROTOCOL_GUID;
EFI_GUID_STRING
(&gEfiSmmUsbDispatchProtocolGuid, "SMM USB SMI Dispatch Protocol", "EFI 2.0 SMM USB SMI Dispatch Protocol");

149
EdkCompatibilityPkg/Foundation/Framework/Protocol/SmmUsbDispatch/SmmUsbDispatch.h Normal file
View File

@@ -0,0 +1,149 @@
/*++
Copyright (c) 1999 - 2002, 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
Abstract:
EFI Smm USB Smi Child Protocol
Revision History
--*/
#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 \
}
EFI_FORWARD_DECLARATION (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
//
typedef
VOID
(EFIAPI *EFI_SMM_USB_DISPATCH) (
IN EFI_HANDLE DispatchHandle,
IN EFI_SMM_USB_DISPATCH_CONTEXT * DispatchContext
);
/*++
Routine Description:
Dispatch function for a USB SMI handler.
Arguments:
DispatchHandle - Handle of this dispatch function.
DispatchContext - Pointer to the dispatch function's context.
The DispatchContext fields are filled in
by the dispatching driver prior to
invoking this dispatch function.
Returns:
Nothing
--*/
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
);
/*++
Routine Description:
Register a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchFunction - Pointer to dispatch function to be invoked for
this SMI source
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.
DispatchHandle - Handle of dispatch function, for when interfacing
with the parent Sx state SMM driver.
Returns:
EFI_SUCCESS - The dispatch function has been successfully
registered and the SMI source has been enabled.
EFI_DEVICE_ERROR - The driver was unable to enable the SMI source.
EFI_OUT_OF_RESOURCES - Not enough memory (system or SMM) to manage this
child.
EFI_INVALID_PARAMETER - DispatchContext is invalid. The USB SMI type
is not within valid range.
--*/
typedef
EFI_STATUS
(EFIAPI *EFI_SMM_USB_UNREGISTER) (
IN EFI_SMM_USB_DISPATCH_PROTOCOL * This,
IN EFI_HANDLE DispatchHandle
);
/*++
Routine Description:
Unregister a child SMI source dispatch function with a parent SMM driver
Arguments:
This - Protocol instance pointer.
DispatchHandle - Handle of dispatch function to deregister.
Returns:
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.
EFI_INVALID_PARAMETER - Handle is invalid.
other - TBD
--*/
//
// Interface structure for the SMM USB SMI Dispatch Protocol
//
typedef struct _EFI_SMM_USB_DISPATCH_PROTOCOL {
EFI_SMM_USB_REGISTER Register;
EFI_SMM_USB_UNREGISTER UnRegister;
} EFI_SMM_USB_DISPATCH_PROTOCOL;
extern EFI_GUID gEfiSmmUsbDispatchProtocolGuid;
#endif