diff options
author | Subrata Banik <subrata.banik@intel.com> | 2018-01-25 10:50:39 +0530 |
---|---|---|
committer | Subrata Banik <subrata.banik@intel.com> | 2018-01-31 05:56:07 +0000 |
commit | 8b9f28994a1b5702ce33e62e55d1595b1a056892 (patch) | |
tree | 6aad0300cdc18139fcdb2e15feb8b21e7cb404d2 /src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid | |
parent | bb1e539f1440bc805dd6350ffba9646454334b2f (diff) |
vendorcode/intel: Add UDK2017 support
This patch includes (edk2/UDK2017) all required headers for UDK2017
from EDK2 github project using below command
>> git clone https://github.com/tianocore/edk2.git vUDK2017
commit hash: 66833b2a87d98be8d81d1337c193bcbf0de47d47
Change-Id: If0d5a3fef016c67e9eed6aed9b698b3b13b930c4
Signed-off-by: Subrata Banik <subrata.banik@intel.com>
Reviewed-on: https://review.coreboot.org/23425
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Aaron Durbin <adurbin@chromium.org>
Reviewed-by: Furquan Shaikh <furquan@google.com>
Diffstat (limited to 'src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid')
39 files changed, 4472 insertions, 0 deletions
diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Acpi.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Acpi.h new file mode 100644 index 0000000000..3897ae62ff --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Acpi.h @@ -0,0 +1,46 @@ +/** @file + GUIDs used for ACPI entries in the EFI system table + + These GUIDs point the ACPI tables as defined in the ACPI specifications. + ACPI 2.0 specification defines the ACPI 2.0 GUID. UEFI 2.0 defines the + ACPI 2.0 Table GUID and ACPI Table GUID. + + Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.0 spec. + +**/ + +#ifndef __ACPI_GUID_H__ +#define __ACPI_GUID_H__ + +#define ACPI_TABLE_GUID \ + { \ + 0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +#define EFI_ACPI_TABLE_GUID \ + { \ + 0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \ + } + +#define ACPI_10_TABLE_GUID ACPI_TABLE_GUID + +// +// ACPI 2.0 or newer tables should use EFI_ACPI_TABLE_GUID. +// +#define EFI_ACPI_20_TABLE_GUID EFI_ACPI_TABLE_GUID + +extern EFI_GUID gEfiAcpiTableGuid; +extern EFI_GUID gEfiAcpi10TableGuid; +extern EFI_GUID gEfiAcpi20TableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Apriori.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Apriori.h new file mode 100644 index 0000000000..6d4fc74d40 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Apriori.h @@ -0,0 +1,30 @@ +/** @file + GUID used as an FV filename for A Priori file. The A Priori file contains a + list of FV filenames that the DXE dispatcher will schedule reguardless of + the dependency grammar. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID introduced in PI Version 1.0. + +**/ + +#ifndef __APRIORI_GUID_H__ +#define __APRIORI_GUID_H__ + +#define EFI_APRIORI_GUID \ + { \ + 0xfc510ee7, 0xffdc, 0x11d4, {0xbd, 0x41, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \ + } + +extern EFI_GUID gAprioriGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/AprioriFileName.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/AprioriFileName.h new file mode 100644 index 0000000000..d99893887d --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/AprioriFileName.h @@ -0,0 +1,44 @@ +/** @file + The GUID PEI_APRIORI_FILE_NAME_GUID definition is the file + name of the PEI a priori file that is stored in a firmware + volume. + + Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID introduced in PI Version 1.0. + +**/ + +#ifndef __PEI_APRIORI_FILE_NAME_H__ +#define __PEI_APRIORI_FILE_NAME_H__ + +#define PEI_APRIORI_FILE_NAME_GUID \ + { 0x1b45cc0a, 0x156a, 0x428a, { 0x62, 0XAF, 0x49, 0x86, 0x4d, 0xa0, 0xe6, 0xe6 } } + + +/// +/// This file must be of type EFI_FV_FILETYPE_FREEFORM and must +/// contain a single section of type EFI_SECTION_RAW. For details on +/// firmware volumes, firmware file types, and firmware file section +/// types. +/// +typedef struct { + /// + /// An array of zero or more EFI_GUID type entries that match the file names of PEIM + /// modules in the same Firmware Volume. The maximum number of entries. + /// + EFI_GUID FileNamesWithinVolume[1]; +} PEI_APRIORI_FILE_CONTENTS; + +extern EFI_GUID gPeiAprioriFileNameGuid; + +#endif + diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Btt.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Btt.h new file mode 100644 index 0000000000..e637614f25 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Btt.h @@ -0,0 +1,228 @@ +/** @file + Block Translation Table (BTT) metadata layout definition. + + BTT is a layout and set of rules for doing block I/O that provide powerfail + write atomicity of a single block. + +Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> +This program and the accompanying materials are licensed and made available under +the terms and conditions of the BSD License that accompanies this distribution. +The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php. + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + This metadata layout definition was introduced in UEFI Specification 2.7. + +**/ + +#ifndef _BTT_H_ +#define _BTT_H_ + +/// +/// The BTT layout and behavior is described by the GUID as below. +/// +#define EFI_BTT_ABSTRACTION_GUID \ + { \ + 0x18633bfc, 0x1735, 0x4217, { 0x8a, 0xc9, 0x17, 0x23, 0x92, 0x82, 0xd3, 0xf8 } \ + } + +// +// Alignment of all BTT structures +// +#define EFI_BTT_ALIGNMENT 4096 + +#define EFI_BTT_INFO_UNUSED_LEN 3968 + +#define EFI_BTT_INFO_BLOCK_SIG_LEN 16 + +/// +/// Indicate inconsistent metadata or lost metadata due to unrecoverable media errors. +/// +#define EFI_BTT_INFO_BLOCK_FLAGS_ERROR 0x00000001 + +#define EFI_BTT_INFO_BLOCK_MAJOR_VERSION 2 +#define EFI_BTT_INFO_BLOCK_MINOR_VERSION 0 + +/// +/// Block Translation Table (BTT) Info Block +/// +typedef struct _EFI_BTT_INFO_BLOCK { + /// + /// Signature of the BTT Index Block data structure. + /// Shall be "BTT_ARENA_INFO\0\0". + /// + CHAR8 Sig[EFI_BTT_INFO_BLOCK_SIG_LEN]; + + /// + /// UUID identifying this BTT instance. + /// + GUID Uuid; + + /// + /// UUID of containing namespace. + /// + GUID ParentUuid; + + /// + /// Attributes of this BTT Info Block. + /// + UINT32 Flags; + + /// + /// Major version number. Currently at version 2. + /// + UINT16 Major; + + /// + /// Minor version number. Currently at version 0. + /// + UINT16 Minor; + + /// + /// Advertised LBA size in bytes. I/O requests shall be in this size chunk. + /// + UINT32 ExternalLbaSize; + + /// + /// Advertised number of LBAs in this arena. + /// + UINT32 ExternalNLba; + + /// + /// Internal LBA size shall be greater than or equal to ExternalLbaSize and shall not be smaller than 512 bytes. + /// + UINT32 InternalLbaSize; + + /// + /// Number of internal blocks in the arena data area. + /// + UINT32 InternalNLba; + + /// + /// Number of free blocks maintained for writes to this arena. + /// + UINT32 NFree; + + /// + /// The size of this info block in bytes. + /// + UINT32 InfoSize; + + /// + /// Offset of next arena, relative to the beginning of this arena. + /// + UINT64 NextOff; + + /// + /// Offset of the data area for this arena, relative to the beginning of this arena. + /// + UINT64 DataOff; + + /// + /// Offset of the map for this arena, relative to the beginning of this arena. + /// + UINT64 MapOff; + + /// + /// Offset of the flog for this arena, relative to the beginning of this arena. + /// + UINT64 FlogOff; + + /// + /// Offset of the backup copy of this arena's info block, relative to the beginning of this arena. + /// + UINT64 InfoOff; + + /// + /// Shall be zero. + /// + CHAR8 Unused[EFI_BTT_INFO_UNUSED_LEN]; + + /// + /// 64-bit Fletcher64 checksum of all fields. + /// + UINT64 Checksum; +} EFI_BTT_INFO_BLOCK; + +/// +/// BTT Map entry maps an LBA that indexes into the arena, to its actual location. +/// +typedef struct _EFI_BTT_MAP_ENTRY { + /// + /// Post-map LBA number (block number in this arena's data area) + /// + UINT32 PostMapLba : 30; + + /// + /// When set and Zero is not set, reads on this block return an error. + /// When set and Zero is set, indicate a map entry in its normal, non-error state. + /// + UINT32 Error : 1; + + /// + /// When set and Error is not set, reads on this block return a full block of zeros. + /// When set and Error is set, indicate a map entry in its normal, non-error state. + /// + UINT32 Zero : 1; +} EFI_BTT_MAP_ENTRY; + +/// +/// Alignment of each flog structure +/// +#define EFI_BTT_FLOG_ENTRY_ALIGNMENT 64 + +/// +/// The BTT Flog is both a free list and a log. +/// The Flog size is determined by the EFI_BTT_INFO_BLOCK.NFree which determines how many of these flog +/// entries there are. +/// The Flog location is the highest aligned address in the arena after space for the backup info block. +/// +typedef struct _EFI_BTT_FLOG { + /// + /// Last pre-map LBA written using this flog entry. + /// + UINT32 Lba0; + + /// + /// Old post-map LBA. + /// + UINT32 OldMap0; + + /// + /// New post-map LBA. + /// + UINT32 NewMap0; + + /// + /// The Seq0 field in each flog entry is used to determine which set of fields is newer between the two sets + /// (Lba0, OldMap0, NewMpa0, Seq0 vs Lba1, Oldmap1, NewMap1, Seq1). + /// + UINT32 Seq0; + + /// + /// Alternate lba entry. + /// + UINT32 Lba1; + + /// + /// Alternate old entry. + /// + UINT32 OldMap1; + + /// + /// Alternate new entry. + /// + UINT32 NewMap1; + + /// + /// Alternate Seq entry. + /// + UINT32 Seq1; +} EFI_BTT_FLOG; + +extern GUID gEfiBttAbstractionGuid; + +#endif //_BTT_H_ diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/CapsuleReport.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/CapsuleReport.h new file mode 100644 index 0000000000..051a41bde9 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/CapsuleReport.h @@ -0,0 +1,105 @@ +/** @file + Guid & data structure used for Capsule process result variables + + Copyright (c) 2015, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.4 spec. + +**/ + + +#ifndef _CAPSULE_REPORT_GUID_H__ +#define _CAPSULE_REPORT_GUID_H__ + +// +// This is the GUID for capsule result variable. +// +#define EFI_CAPSULE_REPORT_GUID \ + { \ + 0x39b68c46, 0xf7fb, 0x441b, {0xb6, 0xec, 0x16, 0xb0, 0xf6, 0x98, 0x21, 0xf3 } \ + } + + +typedef struct { + + /// + /// Size in bytes of the variable including any data beyond header as specified by CapsuleGuid + /// + UINT32 VariableTotalSize; + + /// + /// For alignment + /// + UINT32 Reserved; + + /// + /// Guid from EFI_CAPSULE_HEADER + /// + EFI_GUID CapsuleGuid; + + /// + /// Timestamp using system time when processing completed + /// + EFI_TIME CapsuleProcessed; + + /// + /// Result of the capsule processing. Exact interpretation of any error code may depend + /// upon type of capsule processed + /// + EFI_STATUS CapsuleStatus; +} EFI_CAPSULE_RESULT_VARIABLE_HEADER; + + +typedef struct { + + /// + /// Version of this structure, currently 0x00000001 + /// + UINT16 Version; + + /// + /// The index of the payload within the FMP capsule which was processed to generate this report + /// Starting from zero + /// + UINT8 PayloadIndex; + + /// + /// The UpdateImageIndex from EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER + /// (after unsigned conversion from UINT8 to UINT16). + /// + UINT8 UpdateImageIndex; + + /// + /// The UpdateImageTypeId Guid from EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER. + /// + EFI_GUID UpdateImageTypeId; + + /// + /// In case of capsule loaded from disk, the zero-terminated array containing file name of capsule that was processed. + /// In case of capsule submitted directly to UpdateCapsule() there is no file name, and this field is required to contain a single 16-bit zero character + /// which is included in VariableTotalSize. + /// + /// CHAR16 CapsuleFileName[]; + /// + + /// + /// This field will contain a zero-terminated CHAR16 string containing the text representation of the device path of device publishing Firmware Management Protocol + /// (if present). In case where device path is not present and the target is not otherwise known to firmware, or when payload was blocked by policy, or skipped, + /// this field is required to contain a single 16-bit zero character which is included in VariableTotalSize. + /// + /// CHAR16 CapsuleTarget[]; + /// +} EFI_CAPSULE_RESULT_VARIABLE_FMP; + + +extern EFI_GUID gEfiCapsuleReportGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Cper.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Cper.h new file mode 100644 index 0000000000..c53d696983 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Cper.h @@ -0,0 +1,1240 @@ +/** @file + GUIDs and definitions used for Common Platform Error Record. + + Copyright (c) 2011 - 2017, Intel Corporation. All rights reserved.<BR> + (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.7 Specification. + +**/ + +#ifndef __CPER_GUID_H__ +#define __CPER_GUID_H__ + +#pragma pack(1) + +#define EFI_ERROR_RECORD_SIGNATURE_START SIGNATURE_32('C', 'P', 'E', 'R') +#define EFI_ERROR_RECORD_SIGNATURE_END 0xFFFFFFFF + +#define EFI_ERROR_RECORD_REVISION 0x0101 + +/// +/// Error Severity in Error Record Header and Error Section Descriptor +///@{ +#define EFI_GENERIC_ERROR_RECOVERABLE 0x00000000 +#define EFI_GENERIC_ERROR_FATAL 0x00000001 +#define EFI_GENERIC_ERROR_CORRECTED 0x00000002 +#define EFI_GENERIC_ERROR_INFO 0x00000003 +///@} + +/// +/// The validation bit mask indicates the validity of the following fields +/// in Error Record Header. +///@{ +#define EFI_ERROR_RECORD_HEADER_PLATFORM_ID_VALID BIT0 +#define EFI_ERROR_RECORD_HEADER_TIME_STAMP_VALID BIT1 +#define EFI_ERROR_RECORD_HEADER_PARTITION_ID_VALID BIT2 +///@} + +/// +/// Timestamp is precise if this bit is set and correlates to the time of the +/// error event. +/// +#define EFI_ERROR_TIME_STAMP_PRECISE BIT0 + +/// +/// The timestamp correlates to the time when the error information was collected +/// by the system software and may not necessarily represent the time of the error +/// event. The timestamp contains the local time in BCD format. +/// +typedef struct { + UINT8 Seconds; + UINT8 Minutes; + UINT8 Hours; + UINT8 Flag; + UINT8 Day; + UINT8 Month; + UINT8 Year; + UINT8 Century; +} EFI_ERROR_TIME_STAMP; + +/// +/// GUID value indicating the record association with an error event notification type. +///@{ +#define EFI_EVENT_NOTIFICATION_TYEP_CMC_GUID \ + { \ + 0x2DCE8BB1, 0xBDD7, 0x450e, { 0xB9, 0xAD, 0x9C, 0xF4, 0xEB, 0xD4, 0xF8, 0x90 } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_CPE_GUID \ + { \ + 0x4E292F96, 0xD843, 0x4a55, { 0xA8, 0xC2, 0xD4, 0x81, 0xF2, 0x7E, 0xBE, 0xEE } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_MCE_GUID \ + { \ + 0xE8F56FFE, 0x919C, 0x4cc5, { 0xBA, 0x88, 0x65, 0xAB, 0xE1, 0x49, 0x13, 0xBB } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_PCIE_GUID \ + { \ + 0xCF93C01F, 0x1A16, 0x4dfc, { 0xB8, 0xBC, 0x9C, 0x4D, 0xAF, 0x67, 0xC1, 0x04 } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_INIT_GUID \ + { \ + 0xCC5263E8, 0x9308, 0x454a, { 0x89, 0xD0, 0x34, 0x0B, 0xD3, 0x9B, 0xC9, 0x8E } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_NMI_GUID \ + { \ + 0x5BAD89FF, 0xB7E6, 0x42c9, { 0x81, 0x4A, 0xCF, 0x24, 0x85, 0xD6, 0xE9, 0x8A } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_BOOT_GUID \ + { \ + 0x3D61A466, 0xAB40, 0x409a, { 0xA6, 0x98, 0xF3, 0x62, 0xD4, 0x64, 0xB3, 0x8F } \ + } +#define EFI_EVENT_NOTIFICATION_TYEP_DMAR_GUID \ + { \ + 0x667DD791, 0xC6B3, 0x4c27, { 0x8A, 0x6B, 0x0F, 0x8E, 0x72, 0x2D, 0xEB, 0x41 } \ + } +///@} + +/// +/// Error Record Header Flags +///@{ +#define EFI_HW_ERROR_FLAGS_RECOVERED 0x00000001 +#define EFI_HW_ERROR_FLAGS_PREVERR 0x00000002 +#define EFI_HW_ERROR_FLAGS_SIMULATED 0x00000004 +///@} + +/// +/// Common error record header +/// +typedef struct { + UINT32 SignatureStart; + UINT16 Revision; + UINT32 SignatureEnd; + UINT16 SectionCount; + UINT32 ErrorSeverity; + UINT32 ValidationBits; + UINT32 RecordLength; + EFI_ERROR_TIME_STAMP TimeStamp; + EFI_GUID PlatformID; + EFI_GUID PartitionID; + EFI_GUID CreatorID; + EFI_GUID NotificationType; + UINT64 RecordID; + UINT32 Flags; + UINT64 PersistenceInfo; + UINT8 Resv1[12]; + /// + /// An array of SectionCount descriptors for the associated + /// sections. The number of valid sections is equivalent to the + /// SectionCount. The buffer size of the record may include + /// more space to dynamically add additional Section + /// Descriptors to the error record. + /// +} EFI_COMMON_ERROR_RECORD_HEADER; + +#define EFI_ERROR_SECTION_REVISION 0x0100 + +/// +/// Validity Fields in Error Section Descriptor. +/// +#define EFI_ERROR_SECTION_FRU_ID_VALID BIT0 +#define EFI_ERROR_SECTION_FRU_STRING_VALID BIT1 + +/// +/// Flag field contains information that describes the error section +/// in Error Section Descriptor. +/// +#define EFI_ERROR_SECTION_FLAGS_PRIMARY BIT0 +#define EFI_ERROR_SECTION_FLAGS_CONTAINMENT_WARNING BIT1 +#define EFI_ERROR_SECTION_FLAGS_RESET BIT2 +#define EFI_ERROR_SECTION_FLAGS_ERROR_THRESHOLD_EXCEEDED BIT3 +#define EFI_ERROR_SECTION_FLAGS_RESOURCE_NOT_ACCESSIBLE BIT4 +#define EFI_ERROR_SECTION_FLAGS_LATENT_ERROR BIT5 + +/// +/// Error Sectition Type GUIDs in Error Section Descriptor +///@{ +#define EFI_ERROR_SECTION_PROCESSOR_GENERIC_GUID \ + { \ + 0x9876ccad, 0x47b4, 0x4bdb, { 0xb6, 0x5e, 0x16, 0xf1, 0x93, 0xc4, 0xf3, 0xdb } \ + } +#define EFI_ERROR_SECTION_PROCESSOR_SPECIFIC_GUID \ + { \ + 0xdc3ea0b0, 0xa144, 0x4797, { 0xb9, 0x5b, 0x53, 0xfa, 0x24, 0x2b, 0x6e, 0x1d } \ + } +#define EFI_ERROR_SECTION_PROCESSOR_SPECIFIC_IA32X64_GUID \ + { \ + 0xdc3ea0b0, 0xa144, 0x4797, { 0xb9, 0x5b, 0x53, 0xfa, 0x24, 0x2b, 0x6e, 0x1d } \ + } +#define EFI_ERROR_SECTION_PROCESSOR_SPECIFIC_ARM_GUID \ + { \ + 0xe19e3d16, 0xbc11, 0x11e4, { 0x9c, 0xaa, 0xc2, 0x05, 0x1d, 0x5d, 0x46, 0xb0 } \ + } +#define EFI_ERROR_SECTION_PLATFORM_MEMORY_GUID \ + { \ + 0xa5bc1114, 0x6f64, 0x4ede, { 0xb8, 0x63, 0x3e, 0x83, 0xed, 0x7c, 0x83, 0xb1 } \ + } +#define EFI_ERROR_SECTION_PLATFORM_MEMORY2_GUID \ + { \ + 0x61EC04FC, 0x48E6, 0xD813, { 0x25, 0xC9, 0x8D, 0xAA, 0x44, 0x75, 0x0B, 0x12 } \ + } +#define EFI_ERROR_SECTION_PCIE_GUID \ + { \ + 0xd995e954, 0xbbc1, 0x430f, { 0xad, 0x91, 0xb4, 0x4d, 0xcb, 0x3c, 0x6f, 0x35 } \ + } +#define EFI_ERROR_SECTION_FW_ERROR_RECORD_GUID \ + { \ + 0x81212a96, 0x09ed, 0x4996, { 0x94, 0x71, 0x8d, 0x72, 0x9c, 0x8e, 0x69, 0xed } \ + } +#define EFI_ERROR_SECTION_PCI_PCIX_BUS_GUID \ + { \ + 0xc5753963, 0x3b84, 0x4095, { 0xbf, 0x78, 0xed, 0xda, 0xd3, 0xf9, 0xc9, 0xdd } \ + } +#define EFI_ERROR_SECTION_PCI_DEVICE_GUID \ + { \ + 0xeb5e4685, 0xca66, 0x4769, { 0xb6, 0xa2, 0x26, 0x06, 0x8b, 0x00, 0x13, 0x26 } \ + } +#define EFI_ERROR_SECTION_DMAR_GENERIC_GUID \ + { \ + 0x5b51fef7, 0xc79d, 0x4434, { 0x8f, 0x1b, 0xaa, 0x62, 0xde, 0x3e, 0x2c, 0x64 } \ + } +#define EFI_ERROR_SECTION_DIRECTED_IO_DMAR_GUID \ + { \ + 0x71761d37, 0x32b2, 0x45cd, { 0xa7, 0xd0, 0xb0, 0xfe, 0xdd, 0x93, 0xe8, 0xcf } \ + } +#define EFI_ERROR_SECTION_IOMMU_DMAR_GUID \ + { \ + 0x036f84e1, 0x7f37, 0x428c, { 0xa7, 0x9e, 0x57, 0x5f, 0xdf, 0xaa, 0x84, 0xec } \ + } +///@} + +/// +/// Error Section Descriptor +/// +typedef struct { + UINT32 SectionOffset; + UINT32 SectionLength; + UINT16 Revision; + UINT8 SecValidMask; + UINT8 Resv1; + UINT32 SectionFlags; + EFI_GUID SectionType; + EFI_GUID FruId; + UINT32 Severity; + CHAR8 FruString[20]; +} EFI_ERROR_SECTION_DESCRIPTOR; + +/// +/// The validation bit mask indicates whether or not each of the following fields are +/// valid in Proessor Generic Error section. +///@{ +#define EFI_GENERIC_ERROR_PROC_TYPE_VALID BIT0 +#define EFI_GENERIC_ERROR_PROC_ISA_VALID BIT1 +#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_VALID BIT2 +#define EFI_GENERIC_ERROR_PROC_OPERATION_VALID BIT3 +#define EFI_GENERIC_ERROR_PROC_FLAGS_VALID BIT4 +#define EFI_GENERIC_ERROR_PROC_LEVEL_VALID BIT5 +#define EFI_GENERIC_ERROR_PROC_VERSION_VALID BIT6 +#define EFI_GENERIC_ERROR_PROC_BRAND_VALID BIT7 +#define EFI_GENERIC_ERROR_PROC_ID_VALID BIT8 +#define EFI_GENERIC_ERROR_PROC_TARGET_ADDR_VALID BIT9 +#define EFI_GENERIC_ERROR_PROC_REQUESTER_ID_VALID BIT10 +#define EFI_GENERIC_ERROR_PROC_RESPONDER_ID_VALID BIT11 +#define EFI_GENERIC_ERROR_PROC_INST_IP_VALID BIT12 +///@} + +/// +/// The type of the processor architecture in Proessor Generic Error section. +///@{ +#define EFI_GENERIC_ERROR_PROC_TYPE_IA32_X64 0x00 +#define EFI_GENERIC_ERROR_PROC_TYPE_IA64 0x01 +///@} + +/// +/// The type of the instruction set executing when the error occurred in Proessor +/// Generic Error section. +///@{ +#define EFI_GENERIC_ERROR_PROC_ISA_IA32 0x00 +#define EFI_GENERIC_ERROR_PROC_ISA_IA64 0x01 +#define EFI_GENERIC_ERROR_PROC_ISA_X64 0x02 +///@} + +/// +/// The type of error that occurred in Proessor Generic Error section. +///@{ +#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_UNKNOWN 0x00 +#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_CACHE 0x01 +#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_TLB 0x02 +#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_BUS 0x04 +#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_MICRO_ARCH 0x08 +///@} + +/// +/// The type of operation in Proessor Generic Error section. +///@{ +#define EFI_GENERIC_ERROR_PROC_OPERATION_GENERIC 0x00 +#define EFI_GENERIC_ERROR_PROC_OPERATION_DATA_READ 0x01 +#define EFI_GENERIC_ERROR_PROC_OPERATION_DATA_WRITE 0x02 +#define EFI_GENERIC_ERROR_PROC_OPERATION_INSTRUCTION_EXEC 0x03 +///@} + +/// +/// Flags bit mask indicates additional information about the error in Proessor Generic +/// Error section +///@{ +#define EFI_GENERIC_ERROR_PROC_FLAGS_RESTARTABLE BIT0 +#define EFI_GENERIC_ERROR_PROC_FLAGS_PRECISE_IP BIT1 +#define EFI_GENERIC_ERROR_PROC_FLAGS_OVERFLOW BIT2 +#define EFI_GENERIC_ERROR_PROC_FLAGS_CORRECTED BIT3 +///@} + +/// +/// Processor Generic Error Section +/// describes processor reported hardware errors for logical processors in the system. +/// +typedef struct { + UINT64 ValidFields; + UINT8 Type; + UINT8 Isa; + UINT8 ErrorType; + UINT8 Operation; + UINT8 Flags; + UINT8 Level; + UINT16 Resv1; + UINT64 VersionInfo; + CHAR8 BrandString[128]; + UINT64 ApicId; + UINT64 TargetAddr; + UINT64 RequestorId; + UINT64 ResponderId; + UINT64 InstructionIP; +} EFI_PROCESSOR_GENERIC_ERROR_DATA; + + +#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) +/// +/// IA32 and x64 Specific definitions. +/// + +/// +/// GUID value indicating the type of Processor Error Information structure +/// in IA32/X64 Processor Error Information Structure. +///@{ +#define EFI_IA32_X64_ERROR_TYPE_CACHE_CHECK_GUID \ + { \ + 0xA55701F5, 0xE3EF, 0x43de, {0xAC, 0x72, 0x24, 0x9B, 0x57, 0x3F, 0xAD, 0x2C } \ + } +#define EFI_IA32_X64_ERROR_TYPE_TLB_CHECK_GUID \ + { \ + 0xFC06B535, 0x5E1F, 0x4562, {0x9F, 0x25, 0x0A, 0x3B, 0x9A, 0xDB, 0x63, 0xC3 } \ + } +#define EFI_IA32_X64_ERROR_TYPE_BUS_CHECK_GUID \ + { \ + 0x1CF3F8B3, 0xC5B1, 0x49a2, {0xAA, 0x59, 0x5E, 0xEF, 0x92, 0xFF, 0xA6, 0x3C } \ + } +#define EFI_IA32_X64_ERROR_TYPE_MS_CHECK_GUID \ + { \ + 0x48AB7F57, 0xDC34, 0x4f6c, {0xA7, 0xD3, 0xB0, 0xB5, 0xB0, 0xA7, 0x43, 0x14 } \ + } +///@} + +/// +/// The validation bit mask indicates which fields in the IA32/X64 Processor +/// Error Record structure are valid. +///@{ +#define EFI_IA32_X64_PROCESSOR_ERROR_APIC_ID_VALID BIT0 +#define EFI_IA32_X64_PROCESSOR_ERROR_CPU_ID_INFO_VALID BIT1 +///@} + +/// +/// IA32/X64 Processor Error Record +/// +typedef struct { + UINT64 ValidFields; + UINT64 ApicId; + UINT8 CpuIdInfo[48]; +} EFI_IA32_X64_PROCESSOR_ERROR_RECORD; + +/// +/// The validation bit mask indicates which fields in the Cache Check structure +/// are valid. +///@{ +#define EFI_CACHE_CHECK_TRANSACTION_TYPE_VALID BIT0 +#define EFI_CACHE_CHECK_OPERATION_VALID BIT1 +#define EFI_CACHE_CHECK_LEVEL_VALID BIT2 +#define EFI_CACHE_CHECK_CONTEXT_CORRUPT_VALID BIT3 +#define EFI_CACHE_CHECK_UNCORRECTED_VALID BIT4 +#define EFI_CACHE_CHECK_PRECISE_IP_VALID BIT5 +#define EFI_CACHE_CHECK_RESTARTABLE_VALID BIT6 +#define EFI_CACHE_CHECK_OVERFLOW_VALID BIT7 +///@} + +/// +/// Type of cache error in the Cache Check structure +///@{ +#define EFI_CACHE_CHECK_ERROR_TYPE_INSTRUCTION 0 +#define EFI_CACHE_CHECK_ERROR_TYPE_DATA_ACCESS 1 +#define EFI_CACHE_CHECK_ERROR_TYPE_GENERIC 2 +///@} + +/// +/// Type of cache operation that caused the error in the Cache +/// Check structure +///@{ +#define EFI_CACHE_CHECK_OPERATION_TYPE_GENERIC 0 +#define EFI_CACHE_CHECK_OPERATION_TYPE_GENERIC_READ 1 +#define EFI_CACHE_CHECK_OPERATION_TYPE_GENERIC_WRITE 2 +#define EFI_CACHE_CHECK_OPERATION_TYPE_DATA_READ 3 +#define EFI_CACHE_CHECK_OPERATION_TYPE_DATA_WRITE 4 +#define EFI_CACHE_CHECK_OPERATION_TYPE_INSTRUCTION_FETCH 5 +#define EFI_CACHE_CHECK_OPERATION_TYPE_PREFETCH 6 +#define EFI_CACHE_CHECK_OPERATION_TYPE_EVICTION 7 +#define EFI_CACHE_CHECK_OPERATION_TYPE_SNOOP 8 +///@} + +/// +/// IA32/X64 Cache Check Structure +/// +typedef struct { + UINT64 ValidFields:16; + UINT64 TransactionType:2; + UINT64 Operation:4; + UINT64 Level:3; + UINT64 ContextCorrupt:1; + UINT64 ErrorUncorrected:1; + UINT64 PreciseIp:1; + UINT64 RestartableIp:1; + UINT64 Overflow:1; + UINT64 Resv1:34; +} EFI_IA32_X64_CACHE_CHECK_INFO; + +/// +/// The validation bit mask indicates which fields in the TLB Check structure +/// are valid. +///@{ +#define EFI_TLB_CHECK_TRANSACTION_TYPE_VALID BIT0 +#define EFI_TLB_CHECK_OPERATION_VALID BIT1 +#define EFI_TLB_CHECK_LEVEL_VALID BIT2 +#define EFI_TLB_CHECK_CONTEXT_CORRUPT_VALID BIT3 +#define EFI_TLB_CHECK_UNCORRECTED_VALID BIT4 +#define EFI_TLB_CHECK_PRECISE_IP_VALID BIT5 +#define EFI_TLB_CHECK_RESTARTABLE_VALID BIT6 +#define EFI_TLB_CHECK_OVERFLOW_VALID BIT7 +///@} + +/// +/// Type of cache error in the TLB Check structure +///@{ +#define EFI_TLB_CHECK_ERROR_TYPE_INSTRUCTION 0 +#define EFI_TLB_CHECK_ERROR_TYPE_DATA_ACCESS 1 +#define EFI_TLB_CHECK_ERROR_TYPE_GENERIC 2 +///@} + +/// +/// Type of cache operation that caused the error in the TLB +/// Check structure +///@{ +#define EFI_TLB_CHECK_OPERATION_TYPE_GENERIC 0 +#define EFI_TLB_CHECK_OPERATION_TYPE_GENERIC_READ 1 +#define EFI_TLB_CHECK_OPERATION_TYPE_GENERIC_WRITE 2 +#define EFI_TLB_CHECK_OPERATION_TYPE_DATA_READ 3 +#define EFI_TLB_CHECK_OPERATION_TYPE_DATA_WRITE 4 +#define EFI_TLB_CHECK_OPERATION_TYPE_INST_FETCH 5 +#define EFI_TLB_CHECK_OPERATION_TYPE_PREFETCH 6 +///@} + +/// +/// IA32/X64 TLB Check Structure +/// +typedef struct { + UINT64 ValidFields:16; + UINT64 TransactionType:2; + UINT64 Operation:4; + UINT64 Level:3; + UINT64 ContextCorrupt:1; + UINT64 ErrorUncorrected:1; + UINT64 PreciseIp:1; + UINT64 RestartableIp:1; + UINT64 Overflow:1; + UINT64 Resv1:34; +} EFI_IA32_X64_TLB_CHECK_INFO; + +/// +/// The validation bit mask indicates which fields in the MS Check structure +/// are valid. +///@{ +#define EFI_BUS_CHECK_TRANSACTION_TYPE_VALID BIT0 +#define EFI_BUS_CHECK_OPERATION_VALID BIT1 +#define EFI_BUS_CHECK_LEVEL_VALID BIT2 +#define EFI_BUS_CHECK_CONTEXT_CORRUPT_VALID BIT3 +#define EFI_BUS_CHECK_UNCORRECTED_VALID BIT4 +#define EFI_BUS_CHECK_PRECISE_IP_VALID BIT5 +#define EFI_BUS_CHECK_RESTARTABLE_VALID BIT6 +#define EFI_BUS_CHECK_OVERFLOW_VALID BIT7 +#define EFI_BUS_CHECK_PARTICIPATION_TYPE_VALID BIT8 +#define EFI_BUS_CHECK_TIME_OUT_VALID BIT9 +#define EFI_BUS_CHECK_ADDRESS_SPACE_VALID BIT10 +///@} + +/// +/// Type of cache error in the Bus Check structure +///@{ +#define EFI_BUS_CHECK_ERROR_TYPE_INSTRUCTION 0 +#define EFI_BUS_CHECK_ERROR_TYPE_DATA_ACCESS 1 +#define EFI_BUS_CHECK_ERROR_TYPE_GENERIC 2 +///@} + +/// +/// Type of cache operation that caused the error in the Bus +/// Check structure +///@{ +#define EFI_BUS_CHECK_OPERATION_TYPE_GENERIC 0 +#define EFI_BUS_CHECK_OPERATION_TYPE_GENERIC_READ 1 +#define EFI_BUS_CHECK_OPERATION_TYPE_GENERIC_WRITE 2 +#define EFI_BUS_CHECK_OPERATION_TYPE_DATA_READ 3 +#define EFI_BUS_CHECK_OPERATION_TYPE_DATA_WRITE 4 +#define EFI_BUS_CHECK_OPERATION_TYPE_INST_FETCH 5 +#define EFI_BUS_CHECK_OPERATION_TYPE_PREFETCH 6 +///@} + +/// +/// Type of Participation +///@{ +#define EFI_BUS_CHECK_PARTICIPATION_TYPE_REQUEST 0 +#define EFI_BUS_CHECK_PARTICIPATION_TYPE_RESPONDED 1 +#define EFI_BUS_CHECK_PARTICIPATION_TYPE_OBSERVED 2 +#define EFI_BUS_CHECK_PARTICIPATION_TYPE_GENERIC 3 +///@} + +/// +/// Type of Address Space +///@{ +#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_MEMORY 0 +#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_RESERVED 1 +#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_IO 2 +#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_OTHER 3 +///@} + +/// +/// IA32/X64 Bus Check Structure +/// +typedef struct { + UINT64 ValidFields:16; + UINT64 TransactionType:2; + UINT64 Operation:4; + UINT64 Level:3; + UINT64 ContextCorrupt:1; + UINT64 ErrorUncorrected:1; + UINT64 PreciseIp:1; + UINT64 RestartableIp:1; + UINT64 Overflow:1; + UINT64 ParticipationType:2; + UINT64 TimeOut:1; + UINT64 AddressSpace:2; + UINT64 Resv1:29; +} EFI_IA32_X64_BUS_CHECK_INFO; + +/// +/// The validation bit mask indicates which fields in the MS Check structure +/// are valid. +///@{ +#define EFI_MS_CHECK_ERROR_TYPE_VALID BIT0 +#define EFI_MS_CHECK_CONTEXT_CORRUPT_VALID BIT1 +#define EFI_MS_CHECK_UNCORRECTED_VALID BIT2 +#define EFI_MS_CHECK_PRECISE_IP_VALID BIT3 +#define EFI_MS_CHECK_RESTARTABLE_VALID BIT4 +#define EFI_MS_CHECK_OVERFLOW_VALID BIT5 +///@} + +/// +/// Error type identifies the operation that caused the error. +///@{ +#define EFI_MS_CHECK_ERROR_TYPE_NO 0 +#define EFI_MS_CHECK_ERROR_TYPE_UNCLASSIFIED 1 +#define EFI_MS_CHECK_ERROR_TYPE_MICROCODE_PARITY 2 +#define EFI_MS_CHECK_ERROR_TYPE_EXTERNAL 3 +#define EFI_MS_CHECK_ERROR_TYPE_FRC 4 +#define EFI_MS_CHECK_ERROR_TYPE_INTERNAL_UNCLASSIFIED 5 +///@} + +/// +/// IA32/X64 MS Check Field Description +/// +typedef struct { + UINT64 ValidFields:16; + UINT64 ErrorType:3; + UINT64 ContextCorrupt:1; + UINT64 ErrorUncorrected:1; + UINT64 PreciseIp:1; + UINT64 RestartableIp:1; + UINT64 Overflow:1; + UINT64 Resv1:40; +} EFI_IA32_X64_MS_CHECK_INFO; + +/// +/// IA32/X64 Check Information Item +/// +typedef union { + EFI_IA32_X64_CACHE_CHECK_INFO CacheCheck; + EFI_IA32_X64_TLB_CHECK_INFO TlbCheck; + EFI_IA32_X64_BUS_CHECK_INFO BusCheck; + EFI_IA32_X64_MS_CHECK_INFO MsCheck; + UINT64 Data64; +} EFI_IA32_X64_CHECK_INFO_ITEM; + +/// +/// The validation bit mask indicates which fields in the IA32/X64 Processor Error +/// Information Structure are valid. +///@{ +#define EFI_IA32_X64_ERROR_PROC_CHECK_INFO_VALID BIT0 +#define EFI_IA32_X64_ERROR_PROC_TARGET_ADDR_VALID BIT1 +#define EFI_IA32_X64_ERROR_PROC_REQUESTER_ID_VALID BIT2 +#define EFI_IA32_X64_ERROR_PROC_RESPONDER_ID_VALID BIT3 +#define EFI_IA32_X64_ERROR_PROC_INST_IP_VALID BIT4 +///@} + +/// +/// IA32/X64 Processor Error Information Structure +/// +typedef struct { + EFI_GUID ErrorType; + UINT64 ValidFields; + EFI_IA32_X64_CHECK_INFO_ITEM CheckInfo; + UINT64 TargetId; + UINT64 RequestorId; + UINT64 ResponderId; + UINT64 InstructionIP; +} EFI_IA32_X64_PROCESS_ERROR_INFO; + +/// +/// IA32/X64 Processor Context Information Structure +/// +typedef struct { + UINT16 RegisterType; + UINT16 ArraySize; + UINT32 MsrAddress; + UINT64 MmRegisterAddress; + // + // This field will provide the contents of the actual registers or raw data. + // The number of Registers or size of the raw data reported is determined + // by (Array Size / 8) or otherwise specified by the context structure type + // definition. + // +} EFI_IA32_X64_PROCESSOR_CONTEXT_INFO; + +/// +/// Register Context Type +///@{ +#define EFI_REG_CONTEXT_TYPE_UNCLASSIFIED 0x0000 +#define EFI_REG_CONTEXT_TYPE_MSR 0x0001 +#define EFI_REG_CONTEXT_TYPE_IA32 0x0002 +#define EFI_REG_CONTEXT_TYPE_X64 0x0003 +#define EFI_REG_CONTEXT_TYPE_FXSAVE 0x0004 +#define EFI_REG_CONTEXT_TYPE_DR_IA32 0x0005 +#define EFI_REG_CONTEXT_TYPE_DR_X64 0x0006 +#define EFI_REG_CONTEXT_TYPE_MEM_MAP 0x0007 +///@} + +/// +/// IA32 Register State +/// +typedef struct { + UINT32 Eax; + UINT32 Ebx; + UINT32 Ecx; + UINT32 Edx; + UINT32 Esi; + UINT32 Edi; + UINT32 Ebp; + UINT32 Esp; + UINT16 Cs; + UINT16 Ds; + UINT16 Ss; + UINT16 Es; + UINT16 Fs; + UINT16 Gs; + UINT32 Eflags; + UINT32 Eip; + UINT32 Cr0; + UINT32 Cr1; + UINT32 Cr2; + UINT32 Cr3; + UINT32 Cr4; + UINT32 Gdtr[2]; + UINT32 Idtr[2]; + UINT16 Ldtr; + UINT16 Tr; +} EFI_CONTEXT_IA32_REGISTER_STATE; + +/// +/// X64 Register State +/// +typedef struct { + UINT64 Rax; + UINT64 Rbx; + UINT64 Rcx; + UINT64 Rdx; + UINT64 Rsi; + UINT64 Rdi; + UINT64 Rbp; + UINT64 Rsp; + UINT64 R8; + UINT64 R9; + UINT64 R10; + UINT64 R11; + UINT64 R12; + UINT64 R13; + UINT64 R14; + UINT64 R15; + UINT16 Cs; + UINT16 Ds; + UINT16 Ss; + UINT16 Es; + UINT16 Fs; + UINT16 Gs; + UINT32 Resv1; + UINT64 Rflags; + UINT64 Rip; + UINT64 Cr0; + UINT64 Cr1; + UINT64 Cr2; + UINT64 Cr3; + UINT64 Cr4; + UINT64 Gdtr[2]; + UINT64 Idtr[2]; + UINT16 Ldtr; + UINT16 Tr; +} EFI_CONTEXT_X64_REGISTER_STATE; + +/// +/// The validation bit mask indicates each of the following field is in IA32/X64 +/// Processor Error Section. +/// +typedef struct { + UINT64 ApicIdValid:1; + UINT64 CpuIdInforValid:1; + UINT64 ErrorInfoNum:6; + UINT64 ContextNum:6; + UINT64 Resv1:50; +} EFI_IA32_X64_VALID_BITS; + +#endif + +/// +/// Error Status Fields +/// +typedef struct { + UINT64 Resv1:8; + UINT64 Type:8; + UINT64 AddressSignal:1; ///< Error in Address signals or in Address portion of transaction + UINT64 ControlSignal:1; ///< Error in Control signals or in Control portion of transaction + UINT64 DataSignal:1; ///< Error in Data signals or in Data portion of transaction + UINT64 DetectedByResponder:1; ///< Error detected by responder + UINT64 DetectedByRequester:1; ///< Error detected by requestor + UINT64 FirstError:1; ///< First Error in the sequence - option field + UINT64 OverflowNotLogged:1; ///< Additional errors were not logged due to lack of resources + UINT64 Resv2:41; +} EFI_GENERIC_ERROR_STATUS; + +/// +/// Error Type +/// +typedef enum { + /// + /// General Internal errors + /// + ErrorInternal = 1, + ErrorBus = 16, + /// + /// Component Internal errors + /// + ErrorMemStorage = 4, // Error in memory device + ErrorTlbStorage = 5, // TLB error in cache + ErrorCacheStorage = 6, + ErrorFunctionalUnit = 7, + ErrorSelftest = 8, + ErrorOverflow = 9, + /// + /// Bus internal errors + /// + ErrorVirtualMap = 17, + ErrorAccessInvalid = 18, // Improper access + ErrorUnimplAccess = 19, // Unimplemented memory access + ErrorLossOfLockstep = 20, + ErrorResponseInvalid= 21, // Response not associated with request + ErrorParity = 22, + ErrorProtocol = 23, + ErrorPath = 24, // Detected path error + ErrorTimeout = 25, // Bus timeout + ErrorPoisoned = 26 // Read data poisoned +} EFI_GENERIC_ERROR_STATUS_ERROR_TYPE; + +/// +/// Validation bit mask indicates which fields in the memory error record are valid +/// in Memory Error section +///@{ +#define EFI_PLATFORM_MEMORY_ERROR_STATUS_VALID BIT0 +#define EFI_PLATFORM_MEMORY_PHY_ADDRESS_VALID BIT1 +#define EFI_PLATFORM_MEMORY_PHY_ADDRESS_MASK_VALID BIT2 +#define EFI_PLATFORM_MEMORY_NODE_VALID BIT3 +#define EFI_PLATFORM_MEMORY_CARD_VALID BIT4 +#define EFI_PLATFORM_MEMORY_MODULE_VALID BIT5 +#define EFI_PLATFORM_MEMORY_BANK_VALID BIT6 +#define EFI_PLATFORM_MEMORY_DEVICE_VALID BIT7 +#define EFI_PLATFORM_MEMORY_ROW_VALID BIT8 +#define EFI_PLATFORM_MEMORY_COLUMN_VALID BIT9 +#define EFI_PLATFORM_MEMORY_BIT_POS_VALID BIT10 +#define EFI_PLATFORM_MEMORY_REQUESTOR_ID_VALID BIT11 +#define EFI_PLATFORM_MEMORY_RESPONDER_ID_VALID BIT12 +#define EFI_PLATFORM_MEMORY_TARGET_ID_VALID BIT13 +#define EFI_PLATFORM_MEMORY_ERROR_TYPE_VALID BIT14 +#define EFI_PLATFORM_MEMORY_ERROR_RANK_NUM_VALID BIT15 +#define EFI_PLATFORM_MEMORY_ERROR_CARD_HANDLE_VALID BIT16 +#define EFI_PLATFORM_MEMORY_ERROR_MODULE_HANDLE_VALID BIT17 +#define EFI_PLATFORM_MEMORY_ERROR_EXTENDED_ROW_BIT_16_17_VALID BIT18 +#define EFI_PLATFORM_MEMORY_ERROR_BANK_GROUP_VALID BIT19 +#define EFI_PLATFORM_MEMORY_ERROR_BANK_ADDRESS_VALID BIT20 +#define EFI_PLATFORM_MEMORY_ERROR_CHIP_IDENTIFICATION_VALID BIT21 +///@} + +/// +/// Memory Error Type identifies the type of error that occurred in Memory +/// Error section +///@{ +#define EFI_PLATFORM_MEMORY_ERROR_UNKNOWN 0x00 +#define EFI_PLATFORM_MEMORY_ERROR_NONE 0x01 +#define EFI_PLATFORM_MEMORY_ERROR_SINGLEBIT_ECC 0x02 +#define EFI_PLATFORM_MEMORY_ERROR_MLTIBIT_ECC 0x03 +#define EFI_PLATFORM_MEMORY_ERROR_SINGLESYMBOLS_CHIPKILL 0x04 +#define EFI_PLATFORM_MEMORY_ERROR_MULTISYMBOL_CHIPKILL 0x05 +#define EFI_PLATFORM_MEMORY_ERROR_MATER_ABORT 0x06 +#define EFI_PLATFORM_MEMORY_ERROR_TARGET_ABORT 0x07 +#define EFI_PLATFORM_MEMORY_ERROR_PARITY 0x08 +#define EFI_PLATFORM_MEMORY_ERROR_WDT 0x09 +#define EFI_PLATFORM_MEMORY_ERROR_INVALID_ADDRESS 0x0A +#define EFI_PLATFORM_MEMORY_ERROR_MIRROR_FAILED 0x0B +#define EFI_PLATFORM_MEMORY_ERROR_SPARING 0x0C +#define EFI_PLATFORM_MEMORY_ERROR_SCRUB_CORRECTED 0x0D +#define EFI_PLATFORM_MEMORY_ERROR_SCRUB_UNCORRECTED 0x0E +#define EFI_PLATFORM_MEMORY_ERROR_MEMORY_MAP_EVENT 0x0F +///@} + +/// +/// Memory Error Section +/// +typedef struct { + UINT64 ValidFields; + EFI_GENERIC_ERROR_STATUS ErrorStatus; + UINT64 PhysicalAddress; // Error physical address + UINT64 PhysicalAddressMask; // Grnaularity + UINT16 Node; // Node # + UINT16 Card; + UINT16 ModuleRank; // Module or Rank# + UINT16 Bank; + UINT16 Device; + UINT16 Row; + UINT16 Column; + UINT16 BitPosition; + UINT64 RequestorId; + UINT64 ResponderId; + UINT64 TargetId; + UINT8 ErrorType; + UINT8 Extended; + UINT16 RankNum; + UINT16 CardHandle; + UINT16 ModuleHandle; +} EFI_PLATFORM_MEMORY_ERROR_DATA; + +/// +/// Validation bit mask indicates which fields in the memory error record 2 are valid +/// in Memory Error section 2 +///@{ +#define EFI_PLATFORM_MEMORY2_ERROR_STATUS_VALID BIT0 +#define EFI_PLATFORM_MEMORY2_PHY_ADDRESS_VALID BIT1 +#define EFI_PLATFORM_MEMORY2_PHY_ADDRESS_MASK_VALID BIT2 +#define EFI_PLATFORM_MEMORY2_NODE_VALID BIT3 +#define EFI_PLATFORM_MEMORY2_CARD_VALID BIT4 +#define EFI_PLATFORM_MEMORY2_MODULE_VALID BIT5 +#define EFI_PLATFORM_MEMORY2_BANK_VALID BIT6 +#define EFI_PLATFORM_MEMORY2_DEVICE_VALID BIT7 +#define EFI_PLATFORM_MEMORY2_ROW_VALID BIT8 +#define EFI_PLATFORM_MEMORY2_COLUMN_VALID BIT9 +#define EFI_PLATFORM_MEMORY2_RANK_VALID BIT10 +#define EFI_PLATFORM_MEMORY2_BIT_POS_VALID BIT11 +#define EFI_PLATFORM_MEMORY2_CHIP_ID_VALID BIT12 +#define EFI_PLATFORM_MEMORY2_MEMORY_ERROR_TYPE_VALID BIT13 +#define EFI_PLATFORM_MEMORY2_STATUS_VALID BIT14 +#define EFI_PLATFORM_MEMORY2_REQUESTOR_ID_VALID BIT15 +#define EFI_PLATFORM_MEMORY2_RESPONDER_ID_VALID BIT16 +#define EFI_PLATFORM_MEMORY2_TARGET_ID_VALID BIT17 +#define EFI_PLATFORM_MEMORY2_CARD_HANDLE_VALID BIT18 +#define EFI_PLATFORM_MEMORY2_MODULE_HANDLE_VALID BIT19 +#define EFI_PLATFORM_MEMORY2_BANK_GROUP_VALID BIT20 +#define EFI_PLATFORM_MEMORY2_BANK_ADDRESS_VALID BIT21 +///@} + +/// +/// Memory Error Type identifies the type of error that occurred in Memory +/// Error section 2 +///@{ +#define EFI_PLATFORM_MEMORY2_ERROR_UNKNOWN 0x00 +#define EFI_PLATFORM_MEMORY2_ERROR_NONE 0x01 +#define EFI_PLATFORM_MEMORY2_ERROR_SINGLEBIT_ECC 0x02 +#define EFI_PLATFORM_MEMORY2_ERROR_MLTIBIT_ECC 0x03 +#define EFI_PLATFORM_MEMORY2_ERROR_SINGLESYMBOL_CHIPKILL 0x04 +#define EFI_PLATFORM_MEMORY2_ERROR_MULTISYMBOL_CHIPKILL 0x05 +#define EFI_PLATFORM_MEMORY2_ERROR_MASTER_ABORT 0x06 +#define EFI_PLATFORM_MEMORY2_ERROR_TARGET_ABORT 0x07 +#define EFI_PLATFORM_MEMORY2_ERROR_PARITY 0x08 +#define EFI_PLATFORM_MEMORY2_ERROR_WDT 0x09 +#define EFI_PLATFORM_MEMORY2_ERROR_INVALID_ADDRESS 0x0A +#define EFI_PLATFORM_MEMORY2_ERROR_MIRROR_BROKEN 0x0B +#define EFI_PLATFORM_MEMORY2_ERROR_MEMORY_SPARING 0x0C +#define EFI_PLATFORM_MEMORY2_ERROR_SCRUB_CORRECTED 0x0D +#define EFI_PLATFORM_MEMORY2_ERROR_SCRUB_UNCORRECTED 0x0E +#define EFI_PLATFORM_MEMORY2_ERROR_MEMORY_MAP_EVENT 0x0F +///@} + +/// +/// Memory Error Section 2 +/// +typedef struct { + UINT64 ValidFields; + EFI_GENERIC_ERROR_STATUS ErrorStatus; + UINT64 PhysicalAddress; // Error physical address + UINT64 PhysicalAddressMask; // Grnaularity + UINT16 Node; // Node # + UINT16 Card; + UINT16 Module; // Module or Rank# + UINT16 Bank; + UINT32 Device; + UINT32 Row; + UINT32 Column; + UINT32 Rank; + UINT32 BitPosition; + UINT8 ChipId; + UINT8 MemErrorType; + UINT8 Status; + UINT8 Reserved; + UINT64 RequestorId; + UINT64 ResponderId; + UINT64 TargetId; + UINT32 CardHandle; + UINT32 ModuleHandle; +} EFI_PLATFORM_MEMORY2_ERROR_DATA; + +/// +/// Validation bits mask indicates which of the following fields is valid +/// in PCI Express Error Record. +///@{ +#define EFI_PCIE_ERROR_PORT_TYPE_VALID BIT0 +#define EFI_PCIE_ERROR_VERSION_VALID BIT1 +#define EFI_PCIE_ERROR_COMMAND_STATUS_VALID BIT2 +#define EFI_PCIE_ERROR_DEVICE_ID_VALID BIT3 +#define EFI_PCIE_ERROR_SERIAL_NO_VALID BIT4 +#define EFI_PCIE_ERROR_BRIDGE_CRL_STS_VALID BIT5 +#define EFI_PCIE_ERROR_CAPABILITY_INFO_VALID BIT6 +#define EFI_PCIE_ERROR_AER_INFO_VALID BIT7 +///@} + +/// +/// PCIe Device/Port Type as defined in the PCI Express capabilities register +///@{ +#define EFI_PCIE_ERROR_PORT_PCIE_ENDPOINT 0x00000000 +#define EFI_PCIE_ERROR_PORT_PCI_ENDPOINT 0x00000001 +#define EFI_PCIE_ERROR_PORT_ROOT_PORT 0x00000004 +#define EFI_PCIE_ERROR_PORT_UPSWITCH_PORT 0x00000005 +#define EFI_PCIE_ERROR_PORT_DOWNSWITCH_PORT 0x00000006 +#define EFI_PCIE_ERROR_PORT_PCIE_TO_PCI_BRIDGE 0x00000007 +#define EFI_PCIE_ERROR_PORT_PCI_TO_PCIE_BRIDGE 0x00000008 +#define EFI_PCIE_ERROR_PORT_ROOT_INT_ENDPOINT 0x00000009 +#define EFI_PCIE_ERROR_PORT_ROOT_EVENT_COLLECTOR 0x0000000A +///@} + +/// +/// PCI Slot number +/// +typedef struct { + UINT16 Resv1:3; + UINT16 Number:13; +} EFI_GENERIC_ERROR_PCI_SLOT; + +/// +/// PCIe Root Port PCI/bridge PCI compatible device number and +/// bus number information to uniquely identify the root port or +/// bridge. Default values for both the bus numbers is zero. +/// +typedef struct { + UINT16 VendorId; + UINT16 DeviceId; + UINT8 ClassCode[3]; + UINT8 Function; + UINT8 Device; + UINT16 Segment; + UINT8 PrimaryOrDeviceBus; + UINT8 SecondaryBus; + EFI_GENERIC_ERROR_PCI_SLOT Slot; + UINT8 Resv1; +} EFI_GENERIC_ERROR_PCIE_DEV_BRIDGE_ID; + +/// +/// PCIe Capability Structure +/// +typedef struct { + UINT8 PcieCap[60]; +} EFI_PCIE_ERROR_DATA_CAPABILITY; + +/// +/// PCIe Advanced Error Reporting Extended Capability Structure. +/// +typedef struct { + UINT8 PcieAer[96]; +} EFI_PCIE_ERROR_DATA_AER; + +/// +/// PCI Express Error Record +/// +typedef struct { + UINT64 ValidFields; + UINT32 PortType; + UINT32 Version; + UINT32 CommandStatus; + UINT32 Resv2; + EFI_GENERIC_ERROR_PCIE_DEV_BRIDGE_ID DevBridge; + UINT64 SerialNo; + UINT32 BridgeControlStatus; + EFI_PCIE_ERROR_DATA_CAPABILITY Capability; + EFI_PCIE_ERROR_DATA_AER AerInfo; +} EFI_PCIE_ERROR_DATA; + +/// +/// Validation bits Indicates which of the following fields is valid +/// in PCI/PCI-X Bus Error Section. +///@{ +#define EFI_PCI_PCIX_BUS_ERROR_STATUS_VALID BIT0 +#define EFI_PCI_PCIX_BUS_ERROR_TYPE_VALID BIT1 +#define EFI_PCI_PCIX_BUS_ERROR_BUS_ID_VALID BIT2 +#define EFI_PCI_PCIX_BUS_ERROR_BUS_ADDRESS_VALID BIT3 +#define EFI_PCI_PCIX_BUS_ERROR_BUS_DATA_VALID BIT4 +#define EFI_PCI_PCIX_BUS_ERROR_COMMAND_VALID BIT5 +#define EFI_PCI_PCIX_BUS_ERROR_REQUESTOR_ID_VALID BIT6 +#define EFI_PCI_PCIX_BUS_ERROR_COMPLETER_ID_VALID BIT7 +#define EFI_PCI_PCIX_BUS_ERROR_TARGET_ID_VALID BIT8 +///@} + +/// +/// PCI Bus Error Type in PCI/PCI-X Bus Error Section +///@{ +#define EFI_PCI_PCIX_BUS_ERROR_UNKNOWN 0x0000 +#define EFI_PCI_PCIX_BUS_ERROR_DATA_PARITY 0x0001 +#define EFI_PCI_PCIX_BUS_ERROR_SYSTEM 0x0002 +#define EFI_PCI_PCIX_BUS_ERROR_MASTER_ABORT 0x0003 +#define EFI_PCI_PCIX_BUS_ERROR_BUS_TIMEOUT 0x0004 +#define EFI_PCI_PCIX_BUS_ERROR_MASTER_DATA_PARITY 0x0005 +#define EFI_PCI_PCIX_BUS_ERROR_ADDRESS_PARITY 0x0006 +#define EFI_PCI_PCIX_BUS_ERROR_COMMAND_PARITY 0x0007 +///@} + +/// +/// PCI/PCI-X Bus Error Section +/// +typedef struct { + UINT64 ValidFields; + EFI_GENERIC_ERROR_STATUS ErrorStatus; + UINT16 Type; + UINT16 BusId; + UINT32 Resv2; + UINT64 BusAddress; + UINT64 BusData; + UINT64 BusCommand; + UINT64 RequestorId; + UINT64 ResponderId; + UINT64 TargetId; +} EFI_PCI_PCIX_BUS_ERROR_DATA; + +/// +/// Validation bits Indicates which of the following fields is valid +/// in PCI/PCI-X Component Error Section. +///@{ +#define EFI_PCI_PCIX_DEVICE_ERROR_STATUS_VALID BIT0 +#define EFI_PCI_PCIX_DEVICE_ERROR_ID_INFO_VALID BIT1 +#define EFI_PCI_PCIX_DEVICE_ERROR_MEM_NUM_VALID BIT2 +#define EFI_PCI_PCIX_DEVICE_ERROR_IO_NUM_VALID BIT3 +#define EFI_PCI_PCIX_DEVICE_ERROR_REG_DATA_PAIR_VALID BIT4 +///@} + +/// +/// PCI/PCI-X Device Identification Information +/// +typedef struct { + UINT16 VendorId; + UINT16 DeviceId; + UINT8 ClassCode[3]; + UINT8 Function; + UINT8 Device; + UINT8 Bus; + UINT8 Segment; + UINT8 Resv1; + UINT32 Resv2; +} EFI_GENERIC_ERROR_PCI_DEVICE_ID; + +/// +/// Identifies the type of firmware error record +///@{ +#define EFI_FIRMWARE_ERROR_TYPE_IPF_SAL 0x00 +#define EFI_FIRMWARE_ERROR_TYPE_SOC_TYPE1 0x01 +#define EFI_FIRMWARE_ERROR_TYPE_SOC_TYPE2 0x02 +///@} + +/// +/// Firmware Error Record Section +/// +typedef struct { + UINT8 ErrorType; + UINT8 Revision; + UINT8 Resv1[6]; + UINT64 RecordId; + EFI_GUID RecordIdGuid; +} EFI_FIRMWARE_ERROR_DATA; + +/// +/// Fault Reason in DMAr Generic Error Section +///@{ +#define EFI_DMA_FAULT_REASON_TABLE_ENTRY_NOT_PRESENT 0x01 +#define EFI_DMA_FAULT_REASON_TABLE_ENTRY_INVALID 0x02 +#define EFI_DMA_FAULT_REASON_ACCESS_MAPPING_TABLE_ERROR 0x03 +#define EFI_DMA_FAULT_REASON_RESV_BIT_ERROR_IN_MAPPING_TABLE 0x04 +#define EFI_DMA_FAULT_REASON_ACCESS_ADDR_OUT_OF_SPACE 0x05 +#define EFI_DMA_FAULT_REASON_INVALID_ACCESS 0x06 +#define EFI_DMA_FAULT_REASON_INVALID_REQUEST 0x07 +#define EFI_DMA_FAULT_REASON_ACCESS_TRANSLATE_TABLE_ERROR 0x08 +#define EFI_DMA_FAULT_REASON_RESV_BIT_ERROR_IN_TRANSLATE_TABLE 0x09 +#define EFI_DMA_FAULT_REASON_INVALID_COMMAOND 0x0A +#define EFI_DMA_FAULT_REASON_ACCESS_COMMAND_BUFFER_ERROR 0x0B +///@} + +/// +/// DMA access type in DMAr Generic Error Section +///@{ +#define EFI_DMA_ACCESS_TYPE_READ 0x00 +#define EFI_DMA_ACCESS_TYPE_WRITE 0x01 +///@} + +/// +/// DMA address type in DMAr Generic Error Section +///@{ +#define EFI_DMA_ADDRESS_UNTRANSLATED 0x00 +#define EFI_DMA_ADDRESS_TRANSLATION 0x01 +///@} + +/// +/// Architecture type in DMAr Generic Error Section +///@{ +#define EFI_DMA_ARCH_TYPE_VT 0x01 +#define EFI_DMA_ARCH_TYPE_IOMMU 0x02 +///@} + +/// +/// DMAr Generic Error Section +/// +typedef struct { + UINT16 RequesterId; + UINT16 SegmentNumber; + UINT8 FaultReason; + UINT8 AccessType; + UINT8 AddressType; + UINT8 ArchType; + UINT64 DeviceAddr; + UINT8 Resv1[16]; +} EFI_DMAR_GENERIC_ERROR_DATA; + +/// +/// Intel VT for Directed I/O specific DMAr Errors +/// +typedef struct { + UINT8 Version; + UINT8 Revision; + UINT8 OemId[6]; + UINT64 Capability; + UINT64 CapabilityEx; + UINT32 GlobalCommand; + UINT32 GlobalStatus; + UINT32 FaultStatus; + UINT8 Resv1[12]; + UINT64 FaultRecord[2]; + UINT64 RootEntry[2]; + UINT64 ContextEntry[2]; + UINT64 PteL6; + UINT64 PteL5; + UINT64 PteL4; + UINT64 PteL3; + UINT64 PteL2; + UINT64 PteL1; +} EFI_DIRECTED_IO_DMAR_ERROR_DATA; + +/// +/// IOMMU specific DMAr Errors +/// +typedef struct { + UINT8 Revision; + UINT8 Resv1[7]; + UINT64 Control; + UINT64 Status; + UINT8 Resv2[8]; + UINT64 EventLogEntry[2]; + UINT8 Resv3[16]; + UINT64 DeviceTableEntry[4]; + UINT64 PteL6; + UINT64 PteL5; + UINT64 PteL4; + UINT64 PteL3; + UINT64 PteL2; + UINT64 PteL1; +} EFI_IOMMU_DMAR_ERROR_DATA; + +#pragma pack() + +extern EFI_GUID gEfiEventNotificationTypeCmcGuid; +extern EFI_GUID gEfiEventNotificationTypeCpeGuid; +extern EFI_GUID gEfiEventNotificationTypeMceGuid; +extern EFI_GUID gEfiEventNotificationTypePcieGuid; +extern EFI_GUID gEfiEventNotificationTypeInitGuid; +extern EFI_GUID gEfiEventNotificationTypeNmiGuid; +extern EFI_GUID gEfiEventNotificationTypeBootGuid; +extern EFI_GUID gEfiEventNotificationTypeDmarGuid; + +extern EFI_GUID gEfiProcessorGenericErrorSectionGuid; +extern EFI_GUID gEfiProcessorSpecificErrorSectionGuid; +extern EFI_GUID gEfiIa32X64ProcessorErrorSectionGuid; +extern EFI_GUID gEfiArmProcessorErrorSectionGuid ; +extern EFI_GUID gEfiPlatformMemoryErrorSectionGuid; +extern EFI_GUID gEfiPlatformMemory2ErrorSectionGuid; +extern EFI_GUID gEfiPcieErrorSectionGuid; +extern EFI_GUID gEfiFirmwareErrorSectionGuid; +extern EFI_GUID gEfiPciBusErrorSectionGuid; +extern EFI_GUID gEfiPciDevErrorSectionGuid; +extern EFI_GUID gEfiDMArGenericErrorSectionGuid; +extern EFI_GUID gEfiDirectedIoDMArErrorSectionGuid; +extern EFI_GUID gEfiIommuDMArErrorSectionGuid; + +#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) +/// +/// IA32 and x64 Specific definitions. +/// + +extern EFI_GUID gEfiIa32X64ErrorTypeCacheCheckGuid; +extern EFI_GUID gEfiIa32X64ErrorTypeTlbCheckGuid; +extern EFI_GUID gEfiIa32X64ErrorTypeBusCheckGuid; +extern EFI_GUID gEfiIa32X64ErrorTypeMsCheckGuid; + +#endif + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/DebugImageInfoTable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/DebugImageInfoTable.h new file mode 100644 index 0000000000..553ebd2588 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/DebugImageInfoTable.h @@ -0,0 +1,80 @@ +/** @file + GUID and related data structures used with the Debug Image Info Table. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in UEFI 2.0 spec. + +**/ + +#ifndef __DEBUG_IMAGE_INFO_GUID_H__ +#define __DEBUG_IMAGE_INFO_GUID_H__ + +#include <Protocol/LoadedImage.h> + +/// +/// EFI_DEBUG_IMAGE_INFO_TABLE configuration table GUID declaration. +/// +#define EFI_DEBUG_IMAGE_INFO_TABLE_GUID \ + { \ + 0x49152e77, 0x1ada, 0x4764, {0xb7, 0xa2, 0x7a, 0xfe, 0xfe, 0xd9, 0x5e, 0x8b } \ + } + +#define EFI_DEBUG_IMAGE_INFO_UPDATE_IN_PROGRESS 0x01 +#define EFI_DEBUG_IMAGE_INFO_TABLE_MODIFIED 0x02 + +#define EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL 0x01 + +typedef struct { + UINT64 Signature; ///< A constant UINT64 that has the value EFI_SYSTEM_TABLE_SIGNATURE + EFI_PHYSICAL_ADDRESS EfiSystemTableBase; ///< The physical address of the EFI system table. + UINT32 Crc32; ///< A 32-bit CRC value that is used to verify the EFI_SYSTEM_TABLE_POINTER structure is valid. +} EFI_SYSTEM_TABLE_POINTER; + +typedef struct { + /// + /// Indicates the type of image info structure. For PE32 EFI images, + /// this is set to EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL. + /// + UINT32 ImageInfoType; + /// + /// A pointer to an instance of the loaded image protocol for the associated image. + /// + EFI_LOADED_IMAGE_PROTOCOL *LoadedImageProtocolInstance; + /// + /// Indicates the image handle of the associated image. + /// + EFI_HANDLE ImageHandle; +} EFI_DEBUG_IMAGE_INFO_NORMAL; + +typedef union { + UINT32 *ImageInfoType; + EFI_DEBUG_IMAGE_INFO_NORMAL *NormalImage; +} EFI_DEBUG_IMAGE_INFO; + +typedef struct { + /// + /// UpdateStatus is used by the system to indicate the state of the debug image info table. + /// + volatile UINT32 UpdateStatus; + /// + /// The number of EFI_DEBUG_IMAGE_INFO elements in the array pointed to by EfiDebugImageInfoTable. + /// + UINT32 TableSize; + /// + /// A pointer to the first element of an array of EFI_DEBUG_IMAGE_INFO structures. + /// + EFI_DEBUG_IMAGE_INFO *EfiDebugImageInfoTable; +} EFI_DEBUG_IMAGE_INFO_TABLE_HEADER; + +extern EFI_GUID gEfiDebugImageInfoTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/DxeServices.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/DxeServices.h new file mode 100644 index 0000000000..be2b5b3e96 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/DxeServices.h @@ -0,0 +1,28 @@ +/** @file + GUID used to identify the DXE Services Table + + Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID introduced in PI Version 1.0. + +**/ + +#ifndef __DXE_SERVICES_GUID_H__ +#define __DXE_SERVICES_GUID_H__ + +#define DXE_SERVICES_TABLE_GUID \ + { \ + 0x5ad34ba, 0x6f02, 0x4214, {0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9 } \ + } + +extern EFI_GUID gEfiDxeServicesTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/EventGroup.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/EventGroup.h new file mode 100644 index 0000000000..04ee0e0fda --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/EventGroup.h @@ -0,0 +1,52 @@ +/** @file + GUIDs for gBS->CreateEventEx Event Groups. Defined in UEFI spec 2.0 and PI 1.2.1. + +Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR> +This program and the accompanying materials are licensed and made available under +the terms and conditions of the BSD License that accompanies this distribution. +The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php. + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef __EVENT_GROUP_GUID__ +#define __EVENT_GROUP_GUID__ + + +#define EFI_EVENT_GROUP_EXIT_BOOT_SERVICES \ + { 0x27abf055, 0xb1b8, 0x4c26, { 0x80, 0x48, 0x74, 0x8f, 0x37, 0xba, 0xa2, 0xdf } } + +extern EFI_GUID gEfiEventExitBootServicesGuid; + + +#define EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE \ + { 0x13fa7698, 0xc831, 0x49c7, { 0x87, 0xea, 0x8f, 0x43, 0xfc, 0xc2, 0x51, 0x96 } } + +extern EFI_GUID gEfiEventVirtualAddressChangeGuid; + + +#define EFI_EVENT_GROUP_MEMORY_MAP_CHANGE \ + { 0x78bee926, 0x692f, 0x48fd, { 0x9e, 0xdb, 0x1, 0x42, 0x2e, 0xf0, 0xd7, 0xab } } + +extern EFI_GUID gEfiEventMemoryMapChangeGuid; + + +#define EFI_EVENT_GROUP_READY_TO_BOOT \ + { 0x7ce88fb3, 0x4bd7, 0x4679, { 0x87, 0xa8, 0xa8, 0xd8, 0xde, 0xe5, 0x0d, 0x2b } } + +extern EFI_GUID gEfiEventReadyToBootGuid; + +#define EFI_EVENT_GROUP_DXE_DISPATCH_GUID \ + { 0x7081e22f, 0xcac6, 0x4053, { 0x94, 0x68, 0x67, 0x57, 0x82, 0xcf, 0x88, 0xe5 }} + +extern EFI_GUID gEfiEventDxeDispatchGuid; + +#define EFI_END_OF_DXE_EVENT_GROUP_GUID \ + { 0x2ce967a, 0xdd7e, 0x4ffc, { 0x9e, 0xe7, 0x81, 0xc, 0xf0, 0x47, 0x8, 0x80 } } + +extern EFI_GUID gEfiEndOfDxeEventGroupGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/EventLegacyBios.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/EventLegacyBios.h new file mode 100644 index 0000000000..f69aa18f9a --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/EventLegacyBios.h @@ -0,0 +1,28 @@ +/** @file + GUID is the name of events used with CreateEventEx in order to be notified + when the EFI boot manager is about to boot a legacy boot option. + Events of this type are notificated just before Int19h is invoked. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID introduced in PI Version 1.0. + +**/ + +#ifndef __EVENT_LEGACY_BIOS_GUID_H__ +#define __EVENT_LEGACY_BIOS_GUID_H__ + +#define EFI_EVENT_LEGACY_BOOT_GUID \ + { 0x2a571201, 0x4966, 0x47f6, {0x8b, 0x86, 0xf3, 0x1e, 0x41, 0xf3, 0x2f, 0x10 } } + +extern EFI_GUID gEfiEventLegacyBootGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileInfo.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileInfo.h new file mode 100644 index 0000000000..5a2e081b46 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileInfo.h @@ -0,0 +1,71 @@ +/** @file + Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.SetInfo() + and EFI_FILE_PROTOCOL.GetInfo() to set or get generic file information. + This GUID is defined in UEFI specification. + +Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> +This program and the accompanying materials are licensed and made available under +the terms and conditions of the BSD License that accompanies this distribution. +The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php. + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef __FILE_INFO_H__ +#define __FILE_INFO_H__ + +#define EFI_FILE_INFO_ID \ + { \ + 0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \ + } + +typedef struct { + /// + /// The size of the EFI_FILE_INFO structure, including the Null-terminated FileName string. + /// + UINT64 Size; + /// + /// The size of the file in bytes. + /// + UINT64 FileSize; + /// + /// PhysicalSize The amount of physical space the file consumes on the file system volume. + /// + UINT64 PhysicalSize; + /// + /// The time the file was created. + /// + EFI_TIME CreateTime; + /// + /// The time when the file was last accessed. + /// + EFI_TIME LastAccessTime; + /// + /// The time when the file's contents were last modified. + /// + EFI_TIME ModificationTime; + /// + /// The attribute bits for the file. + /// + UINT64 Attribute; + /// + /// The Null-terminated name of the file. + /// + CHAR16 FileName[1]; +} EFI_FILE_INFO; + +/// +/// The FileName field of the EFI_FILE_INFO data structure is variable length. +/// Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to +/// be the size of the data structure without the FileName field. The following macro +/// computes this size correctly no matter how big the FileName array is declared. +/// This is required to make the EFI_FILE_INFO data structure ANSI compilant. +/// +#define SIZE_OF_EFI_FILE_INFO OFFSET_OF (EFI_FILE_INFO, FileName) + +extern EFI_GUID gEfiFileInfoGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileSystemInfo.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileSystemInfo.h new file mode 100644 index 0000000000..f666ae5571 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileSystemInfo.h @@ -0,0 +1,63 @@ +/** @file + Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.GetInfo() + or EFI_FILE_PROTOCOL.SetInfo() to get or set information about the system's volume. + This GUID is defined in UEFI specification. + +Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> +This program and the accompanying materials are licensed and made available under +the terms and conditions of the BSD License that accompanies this distribution. +The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php. + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef __FILE_SYSTEM_INFO_H__ +#define __FILE_SYSTEM_INFO_H__ + +#define EFI_FILE_SYSTEM_INFO_ID \ + { \ + 0x9576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \ + } + +typedef struct { + /// + /// The size of the EFI_FILE_SYSTEM_INFO structure, including the Null-terminated VolumeLabel string. + /// + UINT64 Size; + /// + /// TRUE if the volume only supports read access. + /// + BOOLEAN ReadOnly; + /// + /// The number of bytes managed by the file system. + /// + UINT64 VolumeSize; + /// + /// The number of available bytes for use by the file system. + /// + UINT64 FreeSpace; + /// + /// The nominal block size by which files are typically grown. + /// + UINT32 BlockSize; + /// + /// The Null-terminated string that is the volume's label. + /// + CHAR16 VolumeLabel[1]; +} EFI_FILE_SYSTEM_INFO; + +/// +/// The VolumeLabel field of the EFI_FILE_SYSTEM_INFO data structure is variable length. +/// Whenever code needs to know the size of the EFI_FILE_SYSTEM_INFO data structure, it needs +/// to be the size of the data structure without the VolumeLable field. The following macro +/// computes this size correctly no matter how big the VolumeLable array is declared. +/// This is required to make the EFI_FILE_SYSTEM_INFO data structure ANSI compilant. +/// +#define SIZE_OF_EFI_FILE_SYSTEM_INFO OFFSET_OF (EFI_FILE_SYSTEM_INFO, VolumeLabel) + +extern EFI_GUID gEfiFileSystemInfoGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileSystemVolumeLabelInfo.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileSystemVolumeLabelInfo.h new file mode 100644 index 0000000000..0f41f9a34e --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FileSystemVolumeLabelInfo.h @@ -0,0 +1,37 @@ +/** @file + Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.GetInfo() + or EFI_FILE_PROTOCOL.SetInfo() to get or set the system's volume label. + This GUID is defined in UEFI specification. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef __FILE_SYSTEM_VOLUME_LABEL_INFO_H__ +#define __FILE_SYSTEM_VOLUME_LABEL_INFO_H__ + +#define EFI_FILE_SYSTEM_VOLUME_LABEL_ID \ + { \ + 0xDB47D7D3, 0xFE81, 0x11d3, {0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } \ + } + +typedef struct { + /// + /// The Null-terminated string that is the volume's label. + /// + CHAR16 VolumeLabel[1]; +} EFI_FILE_SYSTEM_VOLUME_LABEL; + +#define SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL \ + OFFSET_OF (EFI_FILE_SYSTEM_VOLUME_LABEL, VolumeLabel) + +extern EFI_GUID gEfiFileSystemVolumeLabelInfoIdGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareContentsSigned.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareContentsSigned.h new file mode 100644 index 0000000000..c13a21eb13 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareContentsSigned.h @@ -0,0 +1,26 @@ +/** @file + GUID is used to define the signed section. + + Copyright (c) 2013, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID introduced in PI Version 1.2.1. + +**/ + +#ifndef __FIRMWARE_CONTENTS_SIGNED_GUID_H__ +#define __FIRMWARE_CONTENTS_SIGNED_GUID_H__ + +#define EFI_FIRMWARE_CONTENTS_SIGNED_GUID \ + { 0xf9d89e8, 0x9259, 0x4f76, {0xa5, 0xaf, 0xc, 0x89, 0xe3, 0x40, 0x23, 0xdf } } + +extern EFI_GUID gEfiFirmwareContentsSignedGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareFileSystem2.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareFileSystem2.h new file mode 100644 index 0000000000..9e12fd6084 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareFileSystem2.h @@ -0,0 +1,40 @@ +/** @file + Guid used to define the Firmware File System 2. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs introduced in PI Version 1.0. + +**/ + +#ifndef __FIRMWARE_FILE_SYSTEM2_GUID_H__ +#define __FIRMWARE_FILE_SYSTEM2_GUID_H__ + +/// +/// The firmware volume header contains a data field for +/// the file system GUID +/// +#define EFI_FIRMWARE_FILE_SYSTEM2_GUID \ + { 0x8c8ce578, 0x8a3d, 0x4f1c, { 0x99, 0x35, 0x89, 0x61, 0x85, 0xc3, 0x2d, 0xd3 } } + +/// +/// A Volume Top File (VTF) is a file that must be +/// located such that the last byte of the file is +/// also the last byte of the firmware volume +/// +#define EFI_FFS_VOLUME_TOP_FILE_GUID \ + { 0x1BA0062E, 0xC779, 0x4582, { 0x85, 0x66, 0x33, 0x6A, 0xE8, 0xF7, 0x8F, 0x9 } } + + +extern EFI_GUID gEfiFirmwareFileSystem2Guid; +extern EFI_GUID gEfiFirmwareVolumeTopFileGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareFileSystem3.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareFileSystem3.h new file mode 100644 index 0000000000..37ee56a97a --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FirmwareFileSystem3.h @@ -0,0 +1,30 @@ +/** @file + Guid used to define the Firmware File System 3. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs introduced in PI Version 1.0. + +**/ + +#ifndef __FIRMWARE_FILE_SYSTEM3_GUID_H__ +#define __FIRMWARE_FILE_SYSTEM3_GUID_H__ + +/// +/// The firmware volume header contains a data field for the file system GUID +/// {5473C07A-3DCB-4dca-BD6F-1E9689E7349A} +/// +#define EFI_FIRMWARE_FILE_SYSTEM3_GUID \ + { 0x5473c07a, 0x3dcb, 0x4dca, { 0xbd, 0x6f, 0x1e, 0x96, 0x89, 0xe7, 0x34, 0x9a }} + +extern EFI_GUID gEfiFirmwareFileSystem3Guid; + +#endif // __FIRMWARE_FILE_SYSTEM3_GUID_H__ diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FmpCapsule.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FmpCapsule.h new file mode 100644 index 0000000000..2d97b109d0 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/FmpCapsule.h @@ -0,0 +1,98 @@ +/** @file + Guid & data structure used for Delivering Capsules Containing Updates to Firmware + Management Protocol + + Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.4 spec. + +**/ + + +#ifndef _FMP_CAPSULE_GUID_H__ +#define _FMP_CAPSULE_GUID_H__ + +// +// This is the GUID of the capsule for Firmware Management Protocol. +// +#define EFI_FIRMWARE_MANAGEMENT_CAPSULE_ID_GUID \ + { \ + 0x6dcbd5ed, 0xe82d, 0x4c44, {0xbd, 0xa1, 0x71, 0x94, 0x19, 0x9a, 0xd9, 0x2a } \ + } + +#pragma pack(1) + +typedef struct { + UINT32 Version; + + /// + /// The number of drivers included in the capsule and the number of corresponding + /// offsets stored in ItemOffsetList array. + /// + UINT16 EmbeddedDriverCount; + + /// + /// The number of payload items included in the capsule and the number of + /// corresponding offsets stored in the ItemOffsetList array. + /// + UINT16 PayloadItemCount; + + /// + /// Variable length array of dimension [EmbeddedDriverCount + PayloadItemCount] + /// containing offsets of each of the drivers and payload items contained within the capsule + /// + // UINT64 ItemOffsetList[]; +} EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER; + +typedef struct { + UINT32 Version; + + /// + /// Used to identify device firmware targeted by this update. This guid is matched by + /// system firmware against ImageTypeId field within a EFI_FIRMWARE_IMAGE_DESCRIPTOR + /// + EFI_GUID UpdateImageTypeId; + + /// + /// Passed as ImageIndex in call to EFI_FIRMWARE_MANAGEMENT_PROTOCOL.SetImage() + /// + UINT8 UpdateImageIndex; + UINT8 reserved_bytes[3]; + + /// + /// Size of the binary update image which immediately follows this structure + /// + UINT32 UpdateImageSize; + + /// + /// Size of the VendorCode bytes which optionally immediately follow binary update image in the capsule + /// + UINT32 UpdateVendorCodeSize; + + /// + /// The HardwareInstance to target with this update. If value is zero it means match all + /// HardwareInstances. This field allows update software to target only a single device in + /// cases where there are more than one device with the same ImageTypeId GUID. + /// This header is outside the signed data of the Authentication Info structure and + /// therefore can be modified without changing the Auth data. + /// + UINT64 UpdateHardwareInstance; +} EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER; + +#pragma pack() + + +#define EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION 0x00000001 +#define EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION 0x00000002 + +extern EFI_GUID gEfiFmpCapsuleGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/GlobalVariable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/GlobalVariable.h new file mode 100644 index 0000000000..a0be1a94c6 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/GlobalVariable.h @@ -0,0 +1,192 @@ +/** @file + GUID for EFI (NVRAM) Variables. + + Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in UEFI 2.1 +**/ + +#ifndef __GLOBAL_VARIABLE_GUID_H__ +#define __GLOBAL_VARIABLE_GUID_H__ + +#define EFI_GLOBAL_VARIABLE \ + { \ + 0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C } \ + } + +extern EFI_GUID gEfiGlobalVariableGuid; + +// +// Follow UEFI 2.4 spec: +// To prevent name collisions with possible future globally defined variables, +// other internal firmware data variables that are not defined here must be +// saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or +// any other GUID defined by the UEFI Specification. Implementations must +// only permit the creation of variables with a UEFI Specification-defined +// VendorGuid when these variables are documented in the UEFI Specification. +// +// Note: except the globally defined variables defined below, the spec also defines +// L"Boot####" - A boot load option. +// L"Driver####" - A driver load option. +// L"SysPrep####" - A System Prep application load option. +// L"Key####" - Describes hot key relationship with a Boot#### load option. +// The attribute for them is NV+BS+RT, #### is a printed hex value, and no 0x or h +// is included in the hex value. They can not be expressed as a #define like other globally +// defined variables, it is because we can not list the Boot0000, Boot0001, etc one by one. +// + +/// +/// The language codes that the firmware supports. This value is deprecated. +/// Its attribute is BS+RT. +/// +#define EFI_LANG_CODES_VARIABLE_NAME L"LangCodes" +/// +/// The language code that the system is configured for. This value is deprecated. +/// Its attribute is NV+BS+RT. +/// +#define EFI_LANG_VARIABLE_NAME L"Lang" +/// +/// The firmware's boot managers timeout, in seconds, before initiating the default boot selection. +/// Its attribute is NV+BS+RT. +/// +#define EFI_TIME_OUT_VARIABLE_NAME L"Timeout" +/// +/// The language codes that the firmware supports. +/// Its attribute is BS+RT. +/// +#define EFI_PLATFORM_LANG_CODES_VARIABLE_NAME L"PlatformLangCodes" +/// +/// The language code that the system is configured for. +/// Its attribute is NV+BS+RT. +/// +#define EFI_PLATFORM_LANG_VARIABLE_NAME L"PlatformLang" +/// +/// The device path of the default input/output/error output console. +/// Its attribute is NV+BS+RT. +/// +#define EFI_CON_IN_VARIABLE_NAME L"ConIn" +#define EFI_CON_OUT_VARIABLE_NAME L"ConOut" +#define EFI_ERR_OUT_VARIABLE_NAME L"ErrOut" +/// +/// The device path of all possible input/output/error output devices. +/// Its attribute is BS+RT. +/// +#define EFI_CON_IN_DEV_VARIABLE_NAME L"ConInDev" +#define EFI_CON_OUT_DEV_VARIABLE_NAME L"ConOutDev" +#define EFI_ERR_OUT_DEV_VARIABLE_NAME L"ErrOutDev" +/// +/// The ordered boot option load list. +/// Its attribute is NV+BS+RT. +/// +#define EFI_BOOT_ORDER_VARIABLE_NAME L"BootOrder" +/// +/// The boot option for the next boot only. +/// Its attribute is NV+BS+RT. +/// +#define EFI_BOOT_NEXT_VARIABLE_NAME L"BootNext" +/// +/// The boot option that was selected for the current boot. +/// Its attribute is BS+RT. +/// +#define EFI_BOOT_CURRENT_VARIABLE_NAME L"BootCurrent" +/// +/// The types of boot options supported by the boot manager. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME L"BootOptionSupport" +/// +/// The ordered driver load option list. +/// Its attribute is NV+BS+RT. +/// +#define EFI_DRIVER_ORDER_VARIABLE_NAME L"DriverOrder" +/// +/// The ordered System Prep Application load option list. +/// Its attribute is NV+BS+RT. +/// +#define EFI_SYS_PREP_ORDER_VARIABLE_NAME L"SysPrepOrder" +/// +/// Identifies the level of hardware error record persistence +/// support implemented by the platform. This variable is +/// only modified by firmware and is read-only to the OS. +/// Its attribute is NV+BS+RT. +/// +#define EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME L"HwErrRecSupport" +/// +/// Whether the system is operating in setup mode (1) or not (0). +/// All other values are reserved. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_SETUP_MODE_NAME L"SetupMode" +/// +/// The Key Exchange Key Signature Database. +/// Its attribute is NV+BS+RT+AT. +/// +#define EFI_KEY_EXCHANGE_KEY_NAME L"KEK" +/// +/// The public Platform Key. +/// Its attribute is NV+BS+RT+AT. +/// +#define EFI_PLATFORM_KEY_NAME L"PK" +/// +/// Array of GUIDs representing the type of signatures supported +/// by the platform firmware. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_SIGNATURE_SUPPORT_NAME L"SignatureSupport" +/// +/// Whether the platform firmware is operating in Secure boot mode (1) or not (0). +/// All other values are reserved. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_SECURE_BOOT_MODE_NAME L"SecureBoot" +/// +/// The OEM's default Key Exchange Key Signature Database. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_KEK_DEFAULT_VARIABLE_NAME L"KEKDefault" +/// +/// The OEM's default public Platform Key. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_PK_DEFAULT_VARIABLE_NAME L"PKDefault" +/// +/// The OEM's default secure boot signature store. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_DB_DEFAULT_VARIABLE_NAME L"dbDefault" +/// +/// The OEM's default secure boot blacklist signature store. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_DBX_DEFAULT_VARIABLE_NAME L"dbxDefault" +/// +/// The OEM's default secure boot timestamp signature store. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_DBT_DEFAULT_VARIABLE_NAME L"dbtDefault" +/// +/// Allows the firmware to indicate supported features and actions to the OS. +/// Its attribute is BS+RT. +/// +#define EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME L"OsIndicationsSupported" +/// +/// Allows the OS to request the firmware to enable certain features and to take certain actions. +/// Its attribute is NV+BS+RT. +/// +#define EFI_OS_INDICATIONS_VARIABLE_NAME L"OsIndications" +/// +/// Whether the system is configured to use only vendor provided +/// keys or not. Should be treated as read-only. +/// Its attribute is BS+RT. +/// +#define EFI_VENDOR_KEYS_VARIABLE_NAME L"VendorKeys" + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Gpt.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Gpt.h new file mode 100644 index 0000000000..af2b1a12f8 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Gpt.h @@ -0,0 +1,43 @@ +/** @file + Guids used for the GPT (GUID Partition Table) + + GPT defines a new disk partitioning scheme and also describes + usage of the legacy Master Boot Record (MBR) partitioning scheme. + + Copyright (c) 2006 - 2007, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.1 spec. + +**/ + +#ifndef __GPT_GUID_H__ +#define __GPT_GUID_H__ + +#define EFI_PART_TYPE_UNUSED_GUID \ + { \ + 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } \ + } + +#define EFI_PART_TYPE_EFI_SYSTEM_PART_GUID \ + { \ + 0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b } \ + } + +#define EFI_PART_TYPE_LEGACY_MBR_GUID \ + { \ + 0x024dee41, 0x33e7, 0x11d3, {0x9d, 0x69, 0x00, 0x08, 0xc7, 0x81, 0xf3, 0x9f } \ + } + +extern EFI_GUID gEfiPartTypeUnusedGuid; +extern EFI_GUID gEfiPartTypeSystemPartGuid; +extern EFI_GUID gEfiPartTypeLegacyMbrGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/GraphicsInfoHob.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/GraphicsInfoHob.h new file mode 100644 index 0000000000..46dd29ddb2 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/GraphicsInfoHob.h @@ -0,0 +1,51 @@ +/** @file + Hob guid for Information about the graphics mode. + + Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + This HOB is introduced in in PI Version 1.4. + +**/ + +#ifndef _GRAPHICS_INFO_HOB_GUID_H_ +#define _GRAPHICS_INFO_HOB_GUID_H_ + +#include <Protocol/GraphicsOutput.h> + +#define EFI_PEI_GRAPHICS_INFO_HOB_GUID \ + { \ + 0x39f62cce, 0x6825, 0x4669, { 0xbb, 0x56, 0x54, 0x1a, 0xba, 0x75, 0x3a, 0x07 } \ + } + +#define EFI_PEI_GRAPHICS_DEVICE_INFO_HOB_GUID \ + { \ + 0xe5cb2ac9, 0xd35d, 0x4430, { 0x93, 0x6e, 0x1d, 0xe3, 0x32, 0x47, 0x8d, 0xe7 } \ + } + +typedef struct { + EFI_PHYSICAL_ADDRESS FrameBufferBase; + UINT32 FrameBufferSize; + EFI_GRAPHICS_OUTPUT_MODE_INFORMATION GraphicsMode; +} EFI_PEI_GRAPHICS_INFO_HOB; + +typedef struct { + UINT16 VendorId; ///< Ignore if the value is 0xFFFF. + UINT16 DeviceId; ///< Ignore if the value is 0xFFFF. + UINT16 SubsystemVendorId; ///< Ignore if the value is 0xFFFF. + UINT16 SubsystemId; ///< Ignore if the value is 0xFFFF. + UINT8 RevisionId; ///< Ignore if the value is 0xFF. + UINT8 BarIndex; ///< Ignore if the value is 0xFF. +} EFI_PEI_GRAPHICS_DEVICE_INFO_HOB; + +extern EFI_GUID gEfiGraphicsInfoHobGuid; +extern EFI_GUID gEfiGraphicsDeviceInfoHobGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HardwareErrorVariable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HardwareErrorVariable.h new file mode 100644 index 0000000000..4f644155a1 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HardwareErrorVariable.h @@ -0,0 +1,28 @@ +/** @file + GUID for hardware error record variables. + + Copyright (c) 2007 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in UEFI 2.1. + +**/ + +#ifndef _HARDWARE_ERROR_VARIABLE_GUID_H_ +#define _HARDWARE_ERROR_VARIABLE_GUID_H_ + +#define EFI_HARDWARE_ERROR_VARIABLE \ + { \ + 0x414E6BDD, 0xE47B, 0x47cc, {0xB2, 0x44, 0xBB, 0x61, 0x02, 0x0C, 0xF5, 0x16} \ + } + +extern EFI_GUID gEfiHardwareErrorVariableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiFormMapMethodGuid.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiFormMapMethodGuid.h new file mode 100644 index 0000000000..8b37807f3d --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiFormMapMethodGuid.h @@ -0,0 +1,25 @@ +/** @file + Guid used to identify HII FormMap configuration method. + + Copyright (c) 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in UEFI 2.2 spec. +**/ + +#ifndef __EFI_HII_FORMMAP_GUID_H__ +#define __EFI_HII_FORMMAP_GUID_H__ + +#define EFI_HII_STANDARD_FORM_GUID \ + { 0x3bd2f4ec, 0xe524, 0x46e4, { 0xa9, 0xd8, 0x51, 0x1, 0x17, 0x42, 0x55, 0x62 } } + +extern EFI_GUID gEfiHiiStandardFormGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiKeyBoardLayout.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiKeyBoardLayout.h new file mode 100644 index 0000000000..c2619713ed --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiKeyBoardLayout.h @@ -0,0 +1,27 @@ +/** @file + + HII keyboard layout GUID as defined in UEFI2.1 specification + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.1 spec. + +**/ + +#ifndef __HII_KEYBOARD_LAYOUT_GUID_H__ +#define __HII_KEYBOARD_LAYOUT_GUID_H__ + +#define EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID \ + { 0x14982a4f, 0xb0ed, 0x45b8, { 0xa8, 0x11, 0x5a, 0x7a, 0x9b, 0xc2, 0x32, 0xdf }} + +extern EFI_GUID gEfiHiiKeyBoardLayoutGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiPlatformSetupFormset.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiPlatformSetupFormset.h new file mode 100644 index 0000000000..2503879a4c --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HiiPlatformSetupFormset.h @@ -0,0 +1,35 @@ +/** @file + GUID indicates that the form set contains forms designed to be used + for platform configuration and this form set will be displayed. + +Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> +This program and the accompanying materials are licensed and made available under +the terms and conditions of the BSD License that accompanies this distribution. +The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php. + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in UEFI 2.1. + +**/ + +#ifndef __HII_PLATFORM_SETUP_FORMSET_GUID_H__ +#define __HII_PLATFORM_SETUP_FORMSET_GUID_H__ + +#define EFI_HII_PLATFORM_SETUP_FORMSET_GUID \ + { 0x93039971, 0x8545, 0x4b04, { 0xb4, 0x5e, 0x32, 0xeb, 0x83, 0x26, 0x4, 0xe } } + +#define EFI_HII_DRIVER_HEALTH_FORMSET_GUID \ + { 0xf22fc20c, 0x8cf4, 0x45eb, { 0x8e, 0x6, 0xad, 0x4e, 0x50, 0xb9, 0x5d, 0xd3 } } + +#define EFI_HII_USER_CREDENTIAL_FORMSET_GUID \ + { 0x337f4407, 0x5aee, 0x4b83, { 0xb2, 0xa7, 0x4e, 0xad, 0xca, 0x30, 0x88, 0xcd } } + +extern EFI_GUID gEfiHiiPlatformSetupFormsetGuid; +extern EFI_GUID gEfiHiiDriverHealthFormsetGuid; +extern EFI_GUID gEfiHiiUserCredentialFormsetGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HobList.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HobList.h new file mode 100644 index 0000000000..94c1a58e0f --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/HobList.h @@ -0,0 +1,30 @@ +/** @file + GUIDs used for HOB List entries + + These GUIDs point the HOB List passed from PEI to DXE. + + Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID introduced in PI Version 1.0. + +**/ + +#ifndef __HOB_LIST_GUID_H__ +#define __HOB_LIST_GUID_H__ + +#define HOB_LIST_GUID \ + { \ + 0x7739f24c, 0x93d7, 0x11d4, {0x9a, 0x3a, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +extern EFI_GUID gEfiHobListGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/ImageAuthentication.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/ImageAuthentication.h new file mode 100644 index 0000000000..a81b79b838 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/ImageAuthentication.h @@ -0,0 +1,352 @@ +/** @file + Image signature database are defined for the signed image validation. + + Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.5 spec. +**/ + +#ifndef __IMAGE_AUTHTICATION_H__ +#define __IMAGE_AUTHTICATION_H__ + +#include <Guid/GlobalVariable.h> +#include <Protocol/Hash.h> + +#define EFI_IMAGE_SECURITY_DATABASE_GUID \ + { \ + 0xd719b2cb, 0x3d3a, 0x4596, { 0xa3, 0xbc, 0xda, 0xd0, 0xe, 0x67, 0x65, 0x6f } \ + } + +/// +/// Varialbe name with guid EFI_IMAGE_SECURITY_DATABASE_GUID +/// for the authorized signature database. +/// +#define EFI_IMAGE_SECURITY_DATABASE L"db" +/// +/// Varialbe name with guid EFI_IMAGE_SECURITY_DATABASE_GUID +/// for the forbidden signature database. +/// +#define EFI_IMAGE_SECURITY_DATABASE1 L"dbx" +/// +/// Variable name with guid EFI_IMAGE_SECURITY_DATABASE_GUID +/// for the timestamp signature database. +/// +#define EFI_IMAGE_SECURITY_DATABASE2 L"dbt" + +#define SECURE_BOOT_MODE_ENABLE 1 +#define SECURE_BOOT_MODE_DISABLE 0 + +#define SETUP_MODE 1 +#define USER_MODE 0 + +//*********************************************************************** +// Signature Database +//*********************************************************************** +/// +/// The format of a signature database. +/// +#pragma pack(1) + +typedef struct { + /// + /// An identifier which identifies the agent which added the signature to the list. + /// + EFI_GUID SignatureOwner; + /// + /// The format of the signature is defined by the SignatureType. + /// + UINT8 SignatureData[1]; +} EFI_SIGNATURE_DATA; + +typedef struct { + /// + /// Type of the signature. GUID signature types are defined in below. + /// + EFI_GUID SignatureType; + /// + /// Total size of the signature list, including this header. + /// + UINT32 SignatureListSize; + /// + /// Size of the signature header which precedes the array of signatures. + /// + UINT32 SignatureHeaderSize; + /// + /// Size of each signature. + /// + UINT32 SignatureSize; + /// + /// Header before the array of signatures. The format of this header is specified + /// by the SignatureType. + /// UINT8 SignatureHeader[SignatureHeaderSize]; + /// + /// An array of signatures. Each signature is SignatureSize bytes in length. + /// EFI_SIGNATURE_DATA Signatures[][SignatureSize]; + /// +} EFI_SIGNATURE_LIST; + +typedef struct { + /// + /// The SHA256 hash of an X.509 certificate's To-Be-Signed contents. + /// + EFI_SHA256_HASH ToBeSignedHash; + /// + /// The time that the certificate shall be considered to be revoked. + /// + EFI_TIME TimeOfRevocation; +} EFI_CERT_X509_SHA256; + +typedef struct { + /// + /// The SHA384 hash of an X.509 certificate's To-Be-Signed contents. + /// + EFI_SHA384_HASH ToBeSignedHash; + /// + /// The time that the certificate shall be considered to be revoked. + /// + EFI_TIME TimeOfRevocation; +} EFI_CERT_X509_SHA384; + +typedef struct { + /// + /// The SHA512 hash of an X.509 certificate's To-Be-Signed contents. + /// + EFI_SHA512_HASH ToBeSignedHash; + /// + /// The time that the certificate shall be considered to be revoked. + /// + EFI_TIME TimeOfRevocation; +} EFI_CERT_X509_SHA512; + +#pragma pack() + +/// +/// This identifies a signature containing a SHA-256 hash. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) + +/// 32 bytes. +/// +#define EFI_CERT_SHA256_GUID \ + { \ + 0xc1c41626, 0x504c, 0x4092, {0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28} \ + } + +/// +/// This identifies a signature containing an RSA-2048 key. The key (only the modulus +/// since the public key exponent is known to be 0x10001) shall be stored in big-endian +/// order. +/// The SignatureHeader size shall always be 0. The SignatureSize shall always be 16 (size +/// of SignatureOwner component) + 256 bytes. +/// +#define EFI_CERT_RSA2048_GUID \ + { \ + 0x3c5766e8, 0x269c, 0x4e34, {0xaa, 0x14, 0xed, 0x77, 0x6e, 0x85, 0xb3, 0xb6} \ + } + +/// +/// This identifies a signature containing a RSA-2048 signature of a SHA-256 hash. The +/// SignatureHeader size shall always be 0. The SignatureSize shall always be 16 (size of +/// SignatureOwner component) + 256 bytes. +/// +#define EFI_CERT_RSA2048_SHA256_GUID \ + { \ + 0xe2b36190, 0x879b, 0x4a3d, {0xad, 0x8d, 0xf2, 0xe7, 0xbb, 0xa3, 0x27, 0x84} \ + } + +/// +/// This identifies a signature containing a SHA-1 hash. The SignatureSize shall always +/// be 16 (size of SignatureOwner component) + 20 bytes. +/// +#define EFI_CERT_SHA1_GUID \ + { \ + 0x826ca512, 0xcf10, 0x4ac9, {0xb1, 0x87, 0xbe, 0x1, 0x49, 0x66, 0x31, 0xbd} \ + } + +/// +/// TThis identifies a signature containing a RSA-2048 signature of a SHA-1 hash. The +/// SignatureHeader size shall always be 0. The SignatureSize shall always be 16 (size of +/// SignatureOwner component) + 256 bytes. +/// +#define EFI_CERT_RSA2048_SHA1_GUID \ + { \ + 0x67f8444f, 0x8743, 0x48f1, {0xa3, 0x28, 0x1e, 0xaa, 0xb8, 0x73, 0x60, 0x80} \ + } + +/// +/// This identifies a signature based on an X.509 certificate. If the signature is an X.509 +/// certificate then verification of the signature of an image should validate the public +/// key certificate in the image using certificate path verification, up to this X.509 +/// certificate as a trusted root. The SignatureHeader size shall always be 0. The +/// SignatureSize may vary but shall always be 16 (size of the SignatureOwner component) + +/// the size of the certificate itself. +/// Note: This means that each certificate will normally be in a separate EFI_SIGNATURE_LIST. +/// +#define EFI_CERT_X509_GUID \ + { \ + 0xa5c059a1, 0x94e4, 0x4aa7, {0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72} \ + } + +/// +/// This identifies a signature containing a SHA-224 hash. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) + +/// 28 bytes. +/// +#define EFI_CERT_SHA224_GUID \ + { \ + 0xb6e5233, 0xa65c, 0x44c9, {0x94, 0x7, 0xd9, 0xab, 0x83, 0xbf, 0xc8, 0xbd} \ + } + +/// +/// This identifies a signature containing a SHA-384 hash. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) + +/// 48 bytes. +/// +#define EFI_CERT_SHA384_GUID \ + { \ + 0xff3e5307, 0x9fd0, 0x48c9, {0x85, 0xf1, 0x8a, 0xd5, 0x6c, 0x70, 0x1e, 0x1} \ + } + +/// +/// This identifies a signature containing a SHA-512 hash. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) + +/// 64 bytes. +/// +#define EFI_CERT_SHA512_GUID \ + { \ + 0x93e0fae, 0xa6c4, 0x4f50, {0x9f, 0x1b, 0xd4, 0x1e, 0x2b, 0x89, 0xc1, 0x9a} \ + } + +/// +/// This identifies a signature containing the SHA256 hash of an X.509 certificate's +/// To-Be-Signed contents, and a time of revocation. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of the SignatureOwner component) +/// + 48 bytes for an EFI_CERT_X509_SHA256 structure. If the TimeOfRevocation is non-zero, +/// the certificate should be considered to be revoked from that time and onwards, and +/// otherwise the certificate shall be considered to always be revoked. +/// +#define EFI_CERT_X509_SHA256_GUID \ + { \ + 0x3bd2a492, 0x96c0, 0x4079, {0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed } \ + } + +/// +/// This identifies a signature containing the SHA384 hash of an X.509 certificate's +/// To-Be-Signed contents, and a time of revocation. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of the SignatureOwner component) +/// + 64 bytes for an EFI_CERT_X509_SHA384 structure. If the TimeOfRevocation is non-zero, +/// the certificate should be considered to be revoked from that time and onwards, and +/// otherwise the certificate shall be considered to always be revoked. +/// +#define EFI_CERT_X509_SHA384_GUID \ + { \ + 0x7076876e, 0x80c2, 0x4ee6, {0xaa, 0xd2, 0x28, 0xb3, 0x49, 0xa6, 0x86, 0x5b } \ + } + +/// +/// This identifies a signature containing the SHA512 hash of an X.509 certificate's +/// To-Be-Signed contents, and a time of revocation. The SignatureHeader size shall +/// always be 0. The SignatureSize shall always be 16 (size of the SignatureOwner component) +/// + 80 bytes for an EFI_CERT_X509_SHA512 structure. If the TimeOfRevocation is non-zero, +/// the certificate should be considered to be revoked from that time and onwards, and +/// otherwise the certificate shall be considered to always be revoked. +/// +#define EFI_CERT_X509_SHA512_GUID \ + { \ + 0x446dbf63, 0x2502, 0x4cda, {0xbc, 0xfa, 0x24, 0x65, 0xd2, 0xb0, 0xfe, 0x9d } \ + } + +/// +/// This identifies a signature containing a DER-encoded PKCS #7 version 1.5 [RFC2315] +/// SignedData value. +/// +#define EFI_CERT_TYPE_PKCS7_GUID \ + { \ + 0x4aafd29d, 0x68df, 0x49ee, {0x8a, 0xa9, 0x34, 0x7d, 0x37, 0x56, 0x65, 0xa7} \ + } + +//*********************************************************************** +// Image Execution Information Table Definition +//*********************************************************************** +typedef UINT32 EFI_IMAGE_EXECUTION_ACTION; + +#define EFI_IMAGE_EXECUTION_AUTHENTICATION 0x00000007 +#define EFI_IMAGE_EXECUTION_AUTH_UNTESTED 0x00000000 +#define EFI_IMAGE_EXECUTION_AUTH_SIG_FAILED 0x00000001 +#define EFI_IMAGE_EXECUTION_AUTH_SIG_PASSED 0x00000002 +#define EFI_IMAGE_EXECUTION_AUTH_SIG_NOT_FOUND 0x00000003 +#define EFI_IMAGE_EXECUTION_AUTH_SIG_FOUND 0x00000004 +#define EFI_IMAGE_EXECUTION_POLICY_FAILED 0x00000005 +#define EFI_IMAGE_EXECUTION_INITIALIZED 0x00000008 + +// +// EFI_IMAGE_EXECUTION_INFO is added to EFI System Configuration Table +// and assigned the GUID EFI_IMAGE_SECURITY_DATABASE_GUID. +// +typedef struct { + /// + /// Describes the action taken by the firmware regarding this image. + /// + EFI_IMAGE_EXECUTION_ACTION Action; + /// + /// Size of all of the entire structure. + /// + UINT32 InfoSize; + /// + /// If this image was a UEFI device driver (for option ROM, for example) this is the + /// null-terminated, user-friendly name for the device. If the image was for an application, + /// then this is the name of the application. If this cannot be determined, then a simple + /// NULL character should be put in this position. + /// CHAR16 Name[]; + /// + + /// + /// For device drivers, this is the device path of the device for which this device driver + /// was intended. In some cases, the driver itself may be stored as part of the system + /// firmware, but this field should record the device's path, not the firmware path. For + /// applications, this is the device path of the application. If this cannot be determined, + /// a simple end-of-path device node should be put in this position. + /// EFI_DEVICE_PATH_PROTOCOL DevicePath; + /// + + /// + /// Zero or more image signatures. If the image contained no signatures, + /// then this field is empty. + /// EFI_SIGNATURE_LIST Signature; + /// +} EFI_IMAGE_EXECUTION_INFO; + + +typedef struct { + /// + /// Number of EFI_IMAGE_EXECUTION_INFO structures. + /// + UINTN NumberOfImages; + /// + /// Number of image instances of EFI_IMAGE_EXECUTION_INFO structures. + /// + // EFI_IMAGE_EXECUTION_INFO InformationInfo[] +} EFI_IMAGE_EXECUTION_INFO_TABLE; + +extern EFI_GUID gEfiImageSecurityDatabaseGuid; +extern EFI_GUID gEfiCertSha256Guid; +extern EFI_GUID gEfiCertRsa2048Guid; +extern EFI_GUID gEfiCertRsa2048Sha256Guid; +extern EFI_GUID gEfiCertSha1Guid; +extern EFI_GUID gEfiCertRsa2048Sha1Guid; +extern EFI_GUID gEfiCertX509Guid; +extern EFI_GUID gEfiCertSha224Guid; +extern EFI_GUID gEfiCertSha384Guid; +extern EFI_GUID gEfiCertSha512Guid; +extern EFI_GUID gEfiCertX509Sha256Guid; +extern EFI_GUID gEfiCertX509Sha384Guid; +extern EFI_GUID gEfiCertX509Sha512Guid; +extern EFI_GUID gEfiCertPkcs7Guid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MdePkgTokenSpace.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MdePkgTokenSpace.h new file mode 100644 index 0000000000..70896ef67d --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MdePkgTokenSpace.h @@ -0,0 +1,25 @@ +/** @file + GUID for MdePkg PCD Token Space + + Copyright (c) 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef _MDEPKG_TOKEN_SPACE_GUID_H_ +#define _MDEPKG_TOKEN_SPACE_GUID_H_ + +#define MDEPKG_TOKEN_SPACE_GUID \ + { \ + 0x914AEBE7, 0x4635, 0x459b, { 0xAA, 0x1C, 0x11, 0xE2, 0x19, 0xB0, 0x3A, 0x10 } \ + } + +extern EFI_GUID gEfiMdePkgTokenSpaceGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryAllocationHob.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryAllocationHob.h new file mode 100644 index 0000000000..788920c480 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryAllocationHob.h @@ -0,0 +1,34 @@ +/** @file + GUIDs for HOBs used in memory allcation + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs introduced in PI Version 1.0. + +**/ + +#ifndef __MEMORY_ALLOCATION_GUID_H__ +#define __MEMORY_ALLOCATION_GUID_H__ + +#define EFI_HOB_MEMORY_ALLOC_BSP_STORE_GUID \ + {0x564b33cd, 0xc92a, 0x4593, {0x90, 0xbf, 0x24, 0x73, 0xe4, 0x3c, 0x63, 0x22} }; + +#define EFI_HOB_MEMORY_ALLOC_STACK_GUID \ + {0x4ed4bf27, 0x4092, 0x42e9, {0x80, 0x7d, 0x52, 0x7b, 0x1d, 0x0, 0xc9, 0xbd} } + +#define EFI_HOB_MEMORY_ALLOC_MODULE_GUID \ + {0xf8e21975, 0x899, 0x4f58, {0xa4, 0xbe, 0x55, 0x25, 0xa9, 0xc6, 0xd7, 0x7a} } + +extern EFI_GUID gEfiHobMemoryAllocBspStoreGuid; +extern EFI_GUID gEfiHobMemoryAllocStackGuid; +extern EFI_GUID gEfiHobMemoryAllocModuleGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryAttributesTable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryAttributesTable.h new file mode 100644 index 0000000000..1292771c22 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryAttributesTable.h @@ -0,0 +1,34 @@ +/** @file + GUIDs used for UEFI Memory Attributes Table in the UEFI 2.6 specification. + + Copyright (c) 2016, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef __UEFI_MEMORY_ATTRIBUTES_TABLE_H__ +#define __UEFI_MEMORY_ATTRIBUTES_TABLE_H__ + +#define EFI_MEMORY_ATTRIBUTES_TABLE_GUID {\ + 0xdcfa911d, 0x26eb, 0x469f, {0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20} \ +} + +typedef struct { + UINT32 Version; + UINT32 NumberOfEntries; + UINT32 DescriptorSize; + UINT32 Reserved; +//EFI_MEMORY_DESCRIPTOR Entry[1]; +} EFI_MEMORY_ATTRIBUTES_TABLE; + +#define EFI_MEMORY_ATTRIBUTES_TABLE_VERSION 0x00000001 + +extern EFI_GUID gEfiMemoryAttributesTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryOverwriteControl.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryOverwriteControl.h new file mode 100644 index 0000000000..35f6343d37 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/MemoryOverwriteControl.h @@ -0,0 +1,76 @@ +/** @file + GUID used for MemoryOverwriteRequestControl UEFI variable defined in + TCG Platform Reset Attack Mitigation Specification 1.00. + See http://trustedcomputinggroup.org for the latest specification + + The purpose of the MemoryOverwriteRequestControl UEFI variable is to give users (e.g., OS, loader) the ability to + indicate to the platform that secrets are present in memory and that the platform firmware must clear memory upon + a restart. The OS loader should not create the variable. Rather, the firmware is required to create it. + + Copyright (c) 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef _MEMORY_OVERWRITE_CONTROL_DATA_GUID_H_ +#define _MEMORY_OVERWRITE_CONTROL_DATA_GUID_H_ + +#define MEMORY_ONLY_RESET_CONTROL_GUID \ + { \ + 0xe20939be, 0x32d4, 0x41be, {0xa1, 0x50, 0x89, 0x7f, 0x85, 0xd4, 0x98, 0x29} \ + } + +/// +/// Variable name is "MemoryOverwriteRequestControl" and it is a 1 byte unsigned value. +/// The attributes should be: +/// EFI_VARIABLE_NON_VOLATILE | +/// EFI_VARIABLE_BOOTSERVICE_ACCESS | +/// EFI_VARIABLE_RUNTIME_ACCESS +/// +#define MEMORY_OVERWRITE_REQUEST_VARIABLE_NAME L"MemoryOverwriteRequestControl" + +/// +/// 0 = Firmware MUST clear the MOR bit +/// 1 = Firmware MUST set the MOR bit +/// +#define MOR_CLEAR_MEMORY_BIT_MASK 0x01 + +/// +/// 0 = Firmware MAY autodetect a clean shutdown of the Static RTM OS. +/// 1 = Firmware MUST NOT autodetect a clean shutdown of the Static RTM OS. +/// +#define MOR_DISABLEAUTODETECT_BIT_MASK 0x10 + +/// +/// MOR field bit offset +/// +#define MOR_CLEAR_MEMORY_BIT_OFFSET 0 +#define MOR_DISABLEAUTODETECT_BIT_OFFSET 4 + +/** + Return the ClearMemory bit value 0 or 1. + + @param mor 1 byte value that contains ClearMemory and DisableAutoDetect bit. + + @return ClearMemory bit value +**/ +#define MOR_CLEAR_MEMORY_VALUE(mor) (((UINT8)(mor) & MOR_CLEAR_MEMORY_BIT_MASK) >> MOR_CLEAR_MEMORY_BIT_OFFSET) + +/** + Return the DisableAutoDetect bit value 0 or 1. + + @param mor 1 byte value that contains ClearMemory and DisableAutoDetect bit. + + @return DisableAutoDetect bit value +**/ +#define MOR_DISABLE_AUTO_DETECT_VALUE(mor) (((UINT8)(mor) & MOR_DISABLEAUTODETECT_BIT_MASK) >> MOR_DISABLEAUTODETECT_BIT_OFFSET) + +extern EFI_GUID gEfiMemoryOverwriteControlDataGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Mps.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Mps.h new file mode 100644 index 0000000000..4d4692e3be --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/Mps.h @@ -0,0 +1,35 @@ +/** @file + GUIDs used for MPS entries in the UEFI 2.0 system table + ACPI is the primary means of exporting MPS information to the OS. MPS only was + included to support Itanium-based platform power on. So don't use it if you don't have too. + + Copyright (c) 2006, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.0 spec. + +**/ + +#ifndef __MPS_GUID_H__ +#define __MPS_GUID_H__ + +#define EFI_MPS_TABLE_GUID \ + { \ + 0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +// +// GUID name defined in spec. +// +#define MPS_TABLE_GUID EFI_MPS_TABLE_GUID + +extern EFI_GUID gEfiMpsTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/PcAnsi.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/PcAnsi.h new file mode 100644 index 0000000000..7ff878d7f1 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/PcAnsi.h @@ -0,0 +1,58 @@ +/** @file + Terminal Device Path Vendor Guid. + + Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.0 spec. + +**/ + +#ifndef __PC_ANSI_H__ +#define __PC_ANSI_H__ + +#define EFI_PC_ANSI_GUID \ + { \ + 0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +#define EFI_VT_100_GUID \ + { \ + 0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +#define EFI_VT_100_PLUS_GUID \ + { \ + 0x7baec70b, 0x57e0, 0x4c76, {0x8e, 0x87, 0x2f, 0x9e, 0x28, 0x08, 0x83, 0x43 } \ + } + +#define EFI_VT_UTF8_GUID \ + { \ + 0xad15a0d6, 0x8bec, 0x4acf, {0xa0, 0x73, 0xd0, 0x1d, 0xe7, 0x7e, 0x2d, 0x88 } \ + } + +#define DEVICE_PATH_MESSAGING_UART_FLOW_CONTROL \ + { \ + 0x37499a9d, 0x542f, 0x4c89, {0xa0, 0x26, 0x35, 0xda, 0x14, 0x20, 0x94, 0xe4 } \ + } + +#define EFI_SAS_DEVICE_PATH_GUID \ + { \ + 0xd487ddb4, 0x008b, 0x11d9, {0xaf, 0xdc, 0x00, 0x10, 0x83, 0xff, 0xca, 0x4d } \ + } + +extern EFI_GUID gEfiPcAnsiGuid; +extern EFI_GUID gEfiVT100Guid; +extern EFI_GUID gEfiVT100PlusGuid; +extern EFI_GUID gEfiVTUTF8Guid; +extern EFI_GUID gEfiUartDevicePathGuid; +extern EFI_GUID gEfiSasDevicePathGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/PropertiesTable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/PropertiesTable.h new file mode 100644 index 0000000000..7fa3826860 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/PropertiesTable.h @@ -0,0 +1,37 @@ +/** @file + GUIDs used for UEFI Properties Table in the UEFI 2.5 specification. + + Copyright (c) 2015, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +**/ + +#ifndef __EFI_PROPERTIES_TABLE_H__ +#define __EFI_PROPERTIES_TABLE_H__ + +#define EFI_PROPERTIES_TABLE_GUID {\ + 0x880aaca3, 0x4adc, 0x4a04, {0x90, 0x79, 0xb7, 0x47, 0x34, 0x8, 0x25, 0xe5} \ +} + +typedef struct { + UINT32 Version; + UINT32 Length; + UINT64 MemoryProtectionAttribute; +} EFI_PROPERTIES_TABLE; + +#define EFI_PROPERTIES_TABLE_VERSION 0x00010000 + +// +// Memory attribute (Not defined bit is reserved) +// +#define EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA 0x1 + +extern EFI_GUID gEfiPropertiesTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SalSystemTable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SalSystemTable.h new file mode 100644 index 0000000000..8994ee7bdf --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SalSystemTable.h @@ -0,0 +1,31 @@ +/** @file + GUIDs used for SAL system table entries in the EFI system table. + + SAL System Table contains Itanium-based processor centric information about + the system. + + Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.0 spec. + +**/ + +#ifndef __SAL_SYSTEM_TABLE_GUID_H__ +#define __SAL_SYSTEM_TABLE_GUID_H__ + +#define SAL_SYSTEM_TABLE_GUID \ + { \ + 0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +extern EFI_GUID gEfiSalSystemTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SmBios.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SmBios.h new file mode 100644 index 0000000000..05e11b7b63 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SmBios.h @@ -0,0 +1,38 @@ +/** @file + GUIDs used to locate the SMBIOS tables in the UEFI 2.5 system table. + + These GUIDs in the system table are the only legal ways to search for and + locate the SMBIOS tables. Do not search the 0xF0000 segment to find SMBIOS + tables. + + Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.5 spec. + +**/ + +#ifndef __SMBIOS_GUID_H__ +#define __SMBIOS_GUID_H__ + +#define SMBIOS_TABLE_GUID \ + { \ + 0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \ + } + +#define SMBIOS3_TABLE_GUID \ + { \ + 0xf2fd1544, 0x9794, 0x4a2c, {0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94 } \ + } + +extern EFI_GUID gEfiSmbiosTableGuid; +extern EFI_GUID gEfiSmbios3TableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/StatusCodeDataTypeId.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/StatusCodeDataTypeId.h new file mode 100644 index 0000000000..8bbc3315bc --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/StatusCodeDataTypeId.h @@ -0,0 +1,789 @@ +/** @file + GUID used to identify id for the caller who is initiating the Status Code. + + Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + These GUIDs and structures are defined in UEFI Platform Initialization Specification 1.2 + Volume 3: Shared Architectural Elements + +**/ + +#ifndef __PI_STATUS_CODE_DATA_TYPE_ID_GUID_H__ +#define __PI_STATUS_CODE_DATA_TYPE_ID_GUID_H__ + +#include <PiDxe.h> +#include <Protocol/DebugSupport.h> + +/// +/// Global ID for the EFI_STATUS_CODE_STRING structure +/// +#define EFI_STATUS_CODE_DATA_TYPE_STRING_GUID \ + { 0x92D11080, 0x496F, 0x4D95, { 0xBE, 0x7E, 0x03, 0x74, 0x88, 0x38, 0x2B, 0x0A } } + +typedef enum { + /// + /// A NULL-terminated ASCII string. + /// + EfiStringAscii, + /// + /// A double NULL-terminated Unicode string. + /// + EfiStringUnicode, + /// + /// An EFI_STATUS_CODE_STRING_TOKEN representing the string. The actual + /// string can be obtained by querying the HII Database + /// + EfiStringToken +} EFI_STRING_TYPE; + +/// +/// Specifies the format of the data in EFI_STATUS_CODE_STRING_DATA.String. +/// +typedef struct { + /// + /// The HII package list which contains the string. Handle is a dynamic value that may + /// not be the same for different boots. Type EFI_HII_HANDLE is defined in + /// EFI_HII_DATABASE_PROTOCOL.NewPackageList() in the UEFI Specification. + /// + EFI_HII_HANDLE Handle; + /// + /// When combined with Handle, the string token can be used to retrieve the string. + /// Type EFI_STRING_ID is defined in EFI_IFR_OP_HEADER in the UEFI Specification. + /// + EFI_STRING_ID Token; +} EFI_STATUS_CODE_STRING_TOKEN; + +typedef union { + /// + /// ASCII formatted string. + /// + CHAR8 *Ascii; + /// + /// Unicode formatted string. + /// + CHAR16 *Unicode; + /// + /// HII handle/token pair. + /// + EFI_STATUS_CODE_STRING_TOKEN Hii; +} EFI_STATUS_CODE_STRING; + +/// +/// This data type defines a string type of extended data. A string can accompany +/// any status code. The string can provide additional information about the +/// status code. The string can be ASCII, Unicode, or a Human Interface Infrastructure +/// (HII) token/GUID pair. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_STATUS_CODE_STRING_DATA) - HeaderSize, and + /// DataHeader.Type should be + /// EFI_STATUS_CODE_DATA_TYPE_STRING_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// Specifies the format of the data in String. + /// + EFI_STRING_TYPE StringType; + /// + /// A pointer to the extended data. The data follows the format specified by + /// StringType. + /// + EFI_STATUS_CODE_STRING String; +} EFI_STATUS_CODE_STRING_DATA; + +extern EFI_GUID gEfiStatusCodeDataTypeStringGuid; + +/// +/// Global ID for the following structures: +/// - EFI_DEVICE_PATH_EXTENDED_DATA +/// - EFI_DEVICE_HANDLE_EXTENDED_DATA +/// - EFI_RESOURCE_ALLOC_FAILURE_ERROR_DATA +/// - EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA +/// - EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA +/// - EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA +/// - EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA +/// - EFI_MEMORY_RANGE_EXTENDED_DATA +/// - EFI_DEBUG_ASSERT_DATA +/// - EFI_STATUS_CODE_EXCEP_EXTENDED_DATA +/// - EFI_STATUS_CODE_START_EXTENDED_DATA +/// - EFI_LEGACY_OPROM_EXTENDED_DATA +/// +#define EFI_STATUS_CODE_SPECIFIC_DATA_GUID \ + { 0x335984bd, 0xe805, 0x409a, { 0xb8, 0xf8, 0xd2, 0x7e, 0xce, 0x5f, 0xf7, 0xa6 } } + +/// +/// Extended data about the device path, which is used for many errors and +/// progress codes to point to the device. +/// +/// The device path is used to point to the physical device in case there is more than one device +/// belonging to the same subclass. For example, the system may contain two USB keyboards and one +/// PS/2* keyboard. The driver that parses the status code can use the device path extended data to +/// differentiate between the three. The index field is not useful in this case because there is no standard +/// numbering convention. Device paths are preferred over using device handles because device handles +/// for a given device can change from one boot to another and do not mean anything beyond Boot +/// Services time. In certain cases, the bus driver may not create a device handle for a given device if it +/// detects a critical error. In these cases, the device path extended data can be used to refer to the +/// device, but there may not be any device handles with an instance of +/// EFI_DEVICE_PATH_PROTOCOL that matches DevicePath. The variable device path structure +/// is included in this structure to make it self sufficient. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA). DataHeader.Size should be the size + /// of variable-length DevicePath, and DataHeader.Size is zero for a virtual + /// device that does not have a device path. DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The device path to the controller or the hardware device. Note that this parameter is a + /// variable-length device path structure and not a pointer to such a structure. This structure is + /// populated only if it is a physical device. For virtual devices, the Size field in DataHeader + /// is set to zero and this field is not populated. + /// + // EFI_DEVICE_PATH_PROTOCOL DevicePath; +} EFI_DEVICE_PATH_EXTENDED_DATA; + +/// +/// Device handle Extended Data. Used for many +/// errors and progress codes to point to the device. +/// +/// The handle of the device with which the progress or error code is associated. The handle is +/// guaranteed to be accurate only at the time the status code is reported. Handles are dynamic entities +/// between boots, so handles cannot be considered to be valid if the system has reset subsequent to the +/// status code being reported. Handles may be used to determine a wide variety of useful information +/// about the source of the status code. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_DEVICE_HANDLE_EXTENDED_DATA) - HeaderSize, and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The device handle. + /// + EFI_HANDLE Handle; +} EFI_DEVICE_HANDLE_EXTENDED_DATA; + +/// +/// This structure defines extended data describing a PCI resource allocation error. +/// +/// @par Note: +/// The following structure contains variable-length fields and cannot be defined as a C-style +/// structure. +/// +/// This extended data conveys details for a PCI resource allocation failure error. See the PCI +/// specification and the ACPI specification for details on PCI resource allocations and the format for +/// resource descriptors. This error does not detail why the resource allocation failed. It may be due to a +/// bad resource request or a lack of available resources to satisfy a valid request. The variable device +/// path structure and the resource structures are included in this structure to make it self sufficient. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be sizeof + /// (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// (DevicePathSize + DevicePathSize + DevicePathSize + + /// sizeof(UINT32) + 3 * sizeof (UINT16) ), and DataHeader.Type + /// should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The PCI BAR. Applicable only for PCI devices. Ignored for all other devices. + /// + UINT32 Bar; + /// + /// DevicePathSize should be zero if it is a virtual device that is not associated with + /// a device path. Otherwise, this parameter is the length of the variable-length + /// DevicePath. + /// + UINT16 DevicePathSize; + /// + /// Represents the size the ReqRes parameter. ReqResSize should be zero if the + /// requested resources are not provided as a part of extended data. + /// + UINT16 ReqResSize; + /// + /// Represents the size the AllocRes parameter. AllocResSize should be zero if the + /// allocated resources are not provided as a part of extended data. + /// + UINT16 AllocResSize; + /// + /// The device path to the controller or the hardware device that did not get the requested + /// resources. Note that this parameter is the variable-length device path structure and not + /// a pointer to this structure. + /// + // EFI_DEVICE_PATH_PROTOCOL DevicePath; + /// + /// The requested resources in the format of an ACPI 2.0 resource descriptor. This + /// parameter is not a pointer; it is the complete resource descriptor. + /// + // UINT8 ReqRes[]; + /// + /// The allocated resources in the format of an ACPI 2.0 resource descriptor. This + /// parameter is not a pointer; it is the complete resource descriptor. + /// + // UINT8 AllocRes[]; +} EFI_RESOURCE_ALLOC_FAILURE_ERROR_DATA; + +/// +/// This structure provides a calculation for base-10 representations. +/// +/// Not consistent with PI 1.2 Specification. +/// This data type is not defined in the PI 1.2 Specification, but is +/// required by several of the other data structures in this file. +/// +typedef struct { + /// + /// The INT16 number by which to multiply the base-2 representation. + /// + INT16 Value; + /// + /// The INT16 number by which to raise the base-2 calculation. + /// + INT16 Exponent; +} EFI_EXP_BASE10_DATA; + +/// +/// This structure provides the voltage at the time of error. It also provides +/// the threshold value indicating the minimum or maximum voltage that is considered +/// an error. If the voltage is less then the threshold, the error indicates that the +/// voltage fell below the minimum acceptable value. If the voltage is greater then the threshold, +/// the error indicates that the voltage rose above the maximum acceptable value. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA) - + /// HeaderSize, and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The voltage value at the time of the error. + /// + EFI_EXP_BASE10_DATA Voltage; + /// + /// The voltage threshold. + /// + EFI_EXP_BASE10_DATA Threshold; +} EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA; + +/// +/// Microcode Update Extended Error Data +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA) - + /// HeaderSize, and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The version of the microcode update from the header. + /// + UINT32 Version; +} EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA; + +/// +/// This structure provides details about the computing unit timer expiration error. +/// The timer limit provides the timeout value of the timer prior to expiration. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA) - + /// HeaderSize, and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The number of seconds that the computing unit timer was configured to expire. + /// + EFI_EXP_BASE10_DATA TimerLimit; +} EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA; + +/// +/// Attribute bits for EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA.Attributes +/// All other attributes are reserved for future use and must be initialized to 0. +/// +///@{ +#define EFI_COMPUTING_UNIT_MISMATCH_SPEED 0x0001 +#define EFI_COMPUTING_UNIT_MISMATCH_FSB_SPEED 0x0002 +#define EFI_COMPUTING_UNIT_MISMATCH_FAMILY 0x0004 +#define EFI_COMPUTING_UNIT_MISMATCH_MODEL 0x0008 +#define EFI_COMPUTING_UNIT_MISMATCH_STEPPING 0x0010 +#define EFI_COMPUTING_UNIT_MISMATCH_CACHE_SIZE 0x0020 +#define EFI_COMPUTING_UNIT_MISMATCH_OEM1 0x1000 +#define EFI_COMPUTING_UNIT_MISMATCH_OEM2 0x2000 +#define EFI_COMPUTING_UNIT_MISMATCH_OEM3 0x4000 +#define EFI_COMPUTING_UNIT_MISMATCH_OEM4 0x8000 +///@} + +/// +/// This structure defines extended data for processor mismatch errors. +/// +/// This provides information to indicate which processors mismatch, and how they mismatch. The +/// status code contains the instance number of the processor that is in error. This structure's +/// Instance indicates the second processor that does not match. This differentiation allows the +/// consumer to determine which two processors do not match. The Attributes indicate what +/// mismatch is being reported. Because Attributes is a bit field, more than one mismatch can be +/// reported with one error code. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_ HOST_PROCESSOR_MISMATCH_ERROR_DATA) - + /// HeaderSize , and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The unit number of the computing unit that does not match. + /// + UINT32 Instance; + /// + /// The attributes describing the failure. + /// + UINT16 Attributes; +} EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA; + +/// +/// This structure provides details about the computing unit thermal failure. +/// +/// This structure provides the temperature at the time of error. It also provides the threshold value +/// indicating the minimum temperature that is considered an error. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_COMPUTING_UNIT_THERMAL_ERROR_DATA) - + /// HeaderSize , and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The thermal value at the time of the error. + /// + EFI_EXP_BASE10_DATA Temperature; + /// + /// The thermal threshold. + /// + EFI_EXP_BASE10_DATA Threshold; +} EFI_COMPUTING_UNIT_THERMAL_ERROR_DATA; + +/// +/// Enumeration of valid cache types +/// +typedef enum { + EfiInitCacheDataOnly, + EfiInitCacheInstrOnly, + EfiInitCacheBoth, + EfiInitCacheUnspecified +} EFI_INIT_CACHE_TYPE; + +/// +/// Embedded cache init extended data +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_CACHE_INIT_DATA) - HeaderSize , and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The cache level. Starts with 1 for level 1 cache. + /// + UINT32 Level; + /// + /// The type of cache. + /// + EFI_INIT_CACHE_TYPE Type; +} EFI_CACHE_INIT_DATA; + +/// +/// +/// +typedef UINT32 EFI_CPU_STATE_CHANGE_CAUSE; + +/// +/// The reasons that the processor is disabled. +/// Used to fill in EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA.Cause. +/// +///@{ +#define EFI_CPU_CAUSE_INTERNAL_ERROR 0x0001 +#define EFI_CPU_CAUSE_THERMAL_ERROR 0x0002 +#define EFI_CPU_CAUSE_SELFTEST_FAILURE 0x0004 +#define EFI_CPU_CAUSE_PREBOOT_TIMEOUT 0x0008 +#define EFI_CPU_CAUSE_FAILED_TO_START 0x0010 +#define EFI_CPU_CAUSE_CONFIG_ERROR 0x0020 +#define EFI_CPU_CAUSE_USER_SELECTION 0x0080 +#define EFI_CPU_CAUSE_BY_ASSOCIATION 0x0100 +#define EFI_CPU_CAUSE_UNSPECIFIED 0x8000 +///@} + +/// +/// This structure provides information about the disabled computing unit. +/// +/// This structure provides details as to why and how the computing unit was disabled. The causes +/// should cover the typical reasons a processor would be disabled. How the processor was disabled is +/// important because there are distinct differences between hardware and software disabling. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA) - + /// HeaderSize, and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The reason for disabling the processor. + /// + UINT32 Cause; + /// + /// TRUE if the processor is disabled via software means such as not listing it in the ACPI tables. + /// Such a processor will respond to Interprocessor Interrupts (IPIs). FALSE if the processor is hardware + /// disabled, which means it is invisible to software and will not respond to IPIs. + /// + BOOLEAN SoftwareDisabled; +} EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA; + +/// +/// Memory Error Granularity Definition +/// +typedef UINT8 EFI_MEMORY_ERROR_GRANULARITY; + +/// +/// Memory Error Granularities. Used to fill in EFI_MEMORY_EXTENDED_ERROR_DATA.Granularity. +/// +///@{ +#define EFI_MEMORY_ERROR_OTHER 0x01 +#define EFI_MEMORY_ERROR_UNKNOWN 0x02 +#define EFI_MEMORY_ERROR_DEVICE 0x03 +#define EFI_MEMORY_ERROR_PARTITION 0x04 +///@} + +/// +/// Memory Error Operation Definition +/// +typedef UINT8 EFI_MEMORY_ERROR_OPERATION; + +/// +/// Memory Error Operations. Used to fill in EFI_MEMORY_EXTENDED_ERROR_DATA.Operation. +/// +///@{ +#define EFI_MEMORY_OPERATION_OTHER 0x01 +#define EFI_MEMORY_OPERATION_UNKNOWN 0x02 +#define EFI_MEMORY_OPERATION_READ 0x03 +#define EFI_MEMORY_OPERATION_WRITE 0x04 +#define EFI_MEMORY_OPERATION_PARTIAL_WRITE 0x05 +///@} + +/// +/// This structure provides specific details about the memory error that was detected. It provides +/// enough information so that consumers can identify the exact failure and provides enough +/// information to enable corrective action if necessary. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_MEMORY_EXTENDED_ERROR_DATA) - HeaderSize, and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The error granularity type. + /// + EFI_MEMORY_ERROR_GRANULARITY Granularity; + /// + /// The operation that resulted in the error being detected. + /// + EFI_MEMORY_ERROR_OPERATION Operation; + /// + /// The error syndrome, vendor-specific ECC syndrome, or CRC data associated with + /// the error. If unknown, should be initialized to 0. + /// Inconsistent with specification here: + /// This field in StatusCodes spec0.9 is defined as UINT32, keep code unchanged. + /// + UINTN Syndrome; + /// + /// The physical address of the error. + /// + EFI_PHYSICAL_ADDRESS Address; + /// + /// The range, in bytes, within which the error address can be determined. + /// + UINTN Resolution; +} EFI_MEMORY_EXTENDED_ERROR_DATA; + +/// +/// A definition to describe that the operation is performed on multiple devices within the array. +/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. +/// +#define EFI_MULTIPLE_MEMORY_DEVICE_OPERATION 0xfffe + +/// +/// A definition to describe that the operation is performed on all devices within the array. +/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. +/// +#define EFI_ALL_MEMORY_DEVICE_OPERATION 0xffff + +/// +/// A definition to describe that the operation is performed on multiple arrays. +/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. +/// +#define EFI_MULTIPLE_MEMORY_ARRAY_OPERATION 0xfffe + +/// +/// A definition to describe that the operation is performed on all the arrays. +/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. +/// +#define EFI_ALL_MEMORY_ARRAY_OPERATION 0xffff + +/// +/// This extended data provides some context that consumers can use to locate a DIMM within the +/// overall memory scheme. +/// +/// This extended data provides some context that consumers can use to locate a DIMM within the +/// overall memory scheme. The Array and Device numbers may indicate a specific DIMM, or they +/// may be populated with the group definitions in "Related Definitions" below. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_STATUS_CODE_DIMM_NUMBER) - HeaderSize, and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The memory array number. + /// + UINT16 Array; + /// + /// The device number within that Array. + /// + UINT16 Device; +} EFI_STATUS_CODE_DIMM_NUMBER; + +/// +/// This structure defines extended data describing memory modules that do not match. +/// +/// This extended data may be used to convey the specifics of memory modules that do not match. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_MEMORY_MODULE_MISMATCH_ERROR_DATA) - + /// HeaderSize, and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The instance number of the memory module that does not match. + /// + EFI_STATUS_CODE_DIMM_NUMBER Instance; +} EFI_MEMORY_MODULE_MISMATCH_ERROR_DATA; + +/// +/// This structure defines extended data describing a memory range. +/// +/// This extended data may be used to convey the specifics of a memory range. Ranges are specified +/// with a start address and a length. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_MEMORY_RANGE_EXTENDED_DATA) - HeaderSize, and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The starting address of the memory range. + /// + EFI_PHYSICAL_ADDRESS Start; + /// + /// The length in bytes of the memory range. + /// + EFI_PHYSICAL_ADDRESS Length; +} EFI_MEMORY_RANGE_EXTENDED_DATA; + +/// +/// This structure provides the assert information that is typically associated with a debug assertion failing. +/// +/// The data indicates the location of the assertion that failed in the source code. This information +/// includes the file name and line number that are necessary to find the failing assertion in source code. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_DEBUG_ASSERT_DATA) - HeaderSize , and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The line number of the source file where the fault was generated. + /// + UINT32 LineNumber; + /// + /// The size in bytes of FileName. + /// + UINT32 FileNameSize; + /// + /// A pointer to a NULL-terminated ASCII or Unicode string that represents + /// the file name of the source file where the fault was generated. + /// + EFI_STATUS_CODE_STRING_DATA *FileName; +} EFI_DEBUG_ASSERT_DATA; + +/// +/// System Context Data EBC/IA32/IPF +/// +typedef union { + /// + /// The context of the EBC virtual machine when the exception was generated. Type + /// EFI_SYSTEM_CONTEXT_EBC is defined in EFI_DEBUG_SUPPORT_PROTOCOL + /// in the UEFI Specification. + /// + EFI_SYSTEM_CONTEXT_EBC SystemContextEbc; + /// + /// The context of the IA-32 processor when the exception was generated. Type + /// EFI_SYSTEM_CONTEXT_IA32 is defined in the + /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification. + /// + EFI_SYSTEM_CONTEXT_IA32 SystemContextIa32; + /// + /// The context of the Itanium(R) processor when the exception was generated. Type + /// EFI_SYSTEM_CONTEXT_IPF is defined in the + /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification. + /// + EFI_SYSTEM_CONTEXT_IPF SystemContextIpf; + /// + /// The context of the X64 processor when the exception was generated. Type + /// EFI_SYSTEM_CONTEXT_X64 is defined in the + /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification. + /// + EFI_SYSTEM_CONTEXT_X64 SystemContextX64; + /// + /// The context of the ARM processor when the exception was generated. Type + /// EFI_SYSTEM_CONTEXT_ARM is defined in the + /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification. + /// + EFI_SYSTEM_CONTEXT_ARM SystemContextArm; +} EFI_STATUS_CODE_EXCEP_SYSTEM_CONTEXT; + +/// +/// This structure defines extended data describing a processor exception error. +/// +/// This extended data allows the processor context that is present at the time of the exception to be +/// reported with the exception. The format and contents of the context data varies depending on the +/// processor architecture. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_STATUS_CODE_EXCEP_EXTENDED_DATA) - HeaderSize, + /// and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The system context. + /// + EFI_STATUS_CODE_EXCEP_SYSTEM_CONTEXT Context; +} EFI_STATUS_CODE_EXCEP_EXTENDED_DATA; + +/// +/// This structure defines extended data describing a call to a driver binding protocol start function. +/// +/// This extended data records information about a Start() function call. Start() is a member of +/// the UEFI Driver Binding Protocol. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_STATUS_CODE_START_EXTENDED_DATA) - HeaderSize, + /// and DataHeader.Type should be + /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The controller handle. + /// + EFI_HANDLE ControllerHandle; + /// + /// The driver binding handle. + /// + EFI_HANDLE DriverBindingHandle; + /// + /// The size of the RemainingDevicePath. It is zero if the Start() function is + /// called with RemainingDevicePath = NULL. The UEFI Specification allows + /// that the Start() function of bus drivers can be called in this way. + /// + UINT16 DevicePathSize; + /// + /// Matches the RemainingDevicePath parameter being passed to the Start() function. + /// Note that this parameter is the variable-length device path and not a pointer + /// to the device path. + /// + // EFI_DEVICE_PATH_PROTOCOL RemainingDevicePath; +} EFI_STATUS_CODE_START_EXTENDED_DATA; + +/// +/// This structure defines extended data describing a legacy option ROM (OpROM). +/// +/// The device handle and ROM image base can be used by consumers to determine which option ROM +/// failed. Due to the black-box nature of legacy option ROMs, the amount of information that can be +/// obtained may be limited. +/// +typedef struct { + /// + /// The data header identifying the data. DataHeader.HeaderSize should be + /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be + /// sizeof (EFI_LEGACY_OPROM_EXTENDED_DATA) - HeaderSize, and + /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID. + /// + EFI_STATUS_CODE_DATA DataHeader; + /// + /// The handle corresponding to the device that this legacy option ROM is being invoked. + /// + EFI_HANDLE DeviceHandle; + /// + /// The base address of the shadowed legacy ROM image. May or may not point to the shadow RAM area. + /// + EFI_PHYSICAL_ADDRESS RomImageBase; +} EFI_LEGACY_OPROM_EXTENDED_DATA; + +extern EFI_GUID gEfiStatusCodeSpecificDataGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SystemResourceTable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SystemResourceTable.h new file mode 100644 index 0000000000..dc7e16bd24 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/SystemResourceTable.h @@ -0,0 +1,125 @@ +/** @file + Guid & data structure used for EFI System Resource Table (ESRT) + + Copyright (c) 2015, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUIDs defined in UEFI 2.5 spec. + +**/ + + +#ifndef _SYSTEM_RESOURCE_TABLE_H__ +#define _SYSTEM_RESOURCE_TABLE_H__ + +#define EFI_SYSTEM_RESOURCE_TABLE_GUID \ + { \ + 0xb122a263, 0x3661, 0x4f68, {0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80 } \ + } + +/// +/// Current Entry Version +/// +#define EFI_SYSTEM_RESOURCE_TABLE_FIRMWARE_RESOURCE_VERSION 1 + +/// +/// Firmware Type Definitions +/// +#define ESRT_FW_TYPE_UNKNOWN 0x00000000 +#define ESRT_FW_TYPE_SYSTEMFIRMWARE 0x00000001 +#define ESRT_FW_TYPE_DEVICEFIRMWARE 0x00000002 +#define ESRT_FW_TYPE_UEFIDRIVER 0x00000003 + +/// +/// Last Attempt Status Values +/// +#define LAST_ATTEMPT_STATUS_SUCCESS 0x00000000 +#define LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL 0x00000001 +#define LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES 0x00000002 +#define LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION 0x00000003 +#define LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT 0x00000004 +#define LAST_ATTEMPT_STATUS_ERROR_AUTH_ERROR 0x00000005 +#define LAST_ATTEMPT_STATUS_ERROR_PWR_EVT_AC 0x00000006 +#define LAST_ATTEMPT_STATUS_ERROR_PWR_EVT_BATT 0x00000007 + +typedef struct { + /// + /// The firmware class field contains a GUID that identifies a firmware component + /// that can be updated via UpdateCapsule(). This GUID must be unique within all + /// entries of the ESRT. + /// + EFI_GUID FwClass; + /// + /// Identifies the type of firmware resource. + /// + UINT32 FwType; + /// + /// The firmware version field represents the current version of the firmware + /// resource, value must always increase as a larger number represents a newer + /// version. + /// + UINT32 FwVersion; + /// + /// The lowest firmware resource version to which a firmware resource can be + /// rolled back for the given system/device. Generally this is used to protect + /// against known and fixed security issues. + /// + UINT32 LowestSupportedFwVersion; + /// + /// The capsule flags field contains the CapsuleGuid flags (bits 0- 15) as defined + /// in the EFI_CAPSULE_HEADER that will be set in the capsule header. + /// + UINT32 CapsuleFlags; + /// + /// The last attempt version field describes the last firmware version for which + /// an update was attempted (uses the same format as Firmware Version). + /// Last Attempt Version is updated each time an UpdateCapsule() is attempted for + /// an ESRT entry and is preserved across reboots (non-volatile). However, in + /// cases where the attempt version is not recorded due to limitations in the + /// update process, the field shall set to zero after a failed update. Similarly, + /// in the case of a removable device, this value is set to 0 in cases where the + /// device has not been updated since being added to the system. + /// + UINT32 LastAttemptVersion; + /// + /// The last attempt status field describes the result of the last firmware update + /// attempt for the firmware resource entry. + /// LastAttemptStatus is updated each time an UpdateCapsule() is attempted for an + /// ESRT entry and is preserved across reboots (non-volatile). + /// If a firmware update has never been attempted or is unknown, for example after + /// fresh insertion of a removable device, LastAttemptStatus must be set to Success. + /// + UINT32 LastAttemptStatus; +} EFI_SYSTEM_RESOURCE_ENTRY; + +typedef struct { + /// + /// The number of firmware resources in the table, must not be zero. + /// + UINT32 FwResourceCount; + /// + /// The maximum number of resource array entries that can be within the table + /// without reallocating the table, must not be zero. + /// + UINT32 FwResourceCountMax; + /// + /// The version of the EFI_SYSTEM_RESOURCE_ENTRY entities used in this table. + /// This field should be set to 1. + /// + UINT64 FwResourceVersion; + /// + /// Array of EFI_SYSTEM_RESOURCE_ENTRY + /// + //EFI_SYSTEM_RESOURCE_ENTRY Entries[]; +} EFI_SYSTEM_RESOURCE_TABLE; + +extern EFI_GUID gEfiSystemResourceTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/VectorHandoffTable.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/VectorHandoffTable.h new file mode 100644 index 0000000000..256b34550f --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/VectorHandoffTable.h @@ -0,0 +1,33 @@ +/** @file + GUID for system configuration table entry that points to the table + in case an entity in DXE wishes to update/change the vector table contents. + + Copyright (c) 2013, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in PI 1.2.1 spec. +**/ + +#ifndef __EFI_VECTOR_HANDOFF_TABLE_H__ +#define __EFI_VECTOR_HANDOFF_TABLE_H__ + +#include <Ppi/VectorHandoffInfo.h> + +// +// System configuration table entry that points to the table +// in case an entity in DXE wishes to update/change the vector +// table contents. +// +#define EFI_VECTOR_HANDOF_TABLE_GUID \ + { 0x996ec11c, 0x5397, 0x4e73, { 0xb5, 0x8f, 0x82, 0x7e, 0x52, 0x90, 0x6d, 0xef }} + +extern EFI_GUID gEfiVectorHandoffTableGuid; + +#endif diff --git a/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/WinCertificate.h b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/WinCertificate.h new file mode 100644 index 0000000000..6dea446ba0 --- /dev/null +++ b/src/vendorcode/intel/edk2/UDK2017/MdePkg/Include/Guid/WinCertificate.h @@ -0,0 +1,128 @@ +/** @file + GUID for UEFI WIN_CERTIFICATE structure. + + Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR> + This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + @par Revision Reference: + GUID defined in UEFI 2.0 spec. +**/ + +#ifndef __EFI_WIN_CERTIFICATE_H__ +#define __EFI_WIN_CERTIFICATE_H__ + +// +// _WIN_CERTIFICATE.wCertificateType +// +#define WIN_CERT_TYPE_PKCS_SIGNED_DATA 0x0002 +#define WIN_CERT_TYPE_EFI_PKCS115 0x0EF0 +#define WIN_CERT_TYPE_EFI_GUID 0x0EF1 + +/// +/// The WIN_CERTIFICATE structure is part of the PE/COFF specification. +/// +typedef struct { + /// + /// The length of the entire certificate, + /// including the length of the header, in bytes. + /// + UINT32 dwLength; + /// + /// The revision level of the WIN_CERTIFICATE + /// structure. The current revision level is 0x0200. + /// + UINT16 wRevision; + /// + /// The certificate type. See WIN_CERT_TYPE_xxx for the UEFI + /// certificate types. The UEFI specification reserves the range of + /// certificate type values from 0x0EF0 to 0x0EFF. + /// + UINT16 wCertificateType; + /// + /// The following is the actual certificate. The format of + /// the certificate depends on wCertificateType. + /// + /// UINT8 bCertificate[ANYSIZE_ARRAY]; + /// +} WIN_CERTIFICATE; + +/// +/// WIN_CERTIFICATE_UEFI_GUID.CertType +/// +#define EFI_CERT_TYPE_RSA2048_SHA256_GUID \ + {0xa7717414, 0xc616, 0x4977, {0x94, 0x20, 0x84, 0x47, 0x12, 0xa7, 0x35, 0xbf } } + +/// +/// WIN_CERTIFICATE_UEFI_GUID.CertData +/// +typedef struct { + EFI_GUID HashType; + UINT8 PublicKey[256]; + UINT8 Signature[256]; +} EFI_CERT_BLOCK_RSA_2048_SHA256; + + +/// +/// Certificate which encapsulates a GUID-specific digital signature +/// +typedef struct { + /// + /// This is the standard WIN_CERTIFICATE header, where + /// wCertificateType is set to WIN_CERT_TYPE_EFI_GUID. + /// + WIN_CERTIFICATE Hdr; + /// + /// This is the unique id which determines the + /// format of the CertData. . + /// + EFI_GUID CertType; + /// + /// The following is the certificate data. The format of + /// the data is determined by the CertType. + /// If CertType is EFI_CERT_TYPE_RSA2048_SHA256_GUID, + /// the CertData will be EFI_CERT_BLOCK_RSA_2048_SHA256 structure. + /// + UINT8 CertData[1]; +} WIN_CERTIFICATE_UEFI_GUID; + + +/// +/// Certificate which encapsulates the RSASSA_PKCS1-v1_5 digital signature. +/// +/// The WIN_CERTIFICATE_UEFI_PKCS1_15 structure is derived from +/// WIN_CERTIFICATE and encapsulate the information needed to +/// implement the RSASSA-PKCS1-v1_5 digital signature algorithm as +/// specified in RFC2437. +/// +typedef struct { + /// + /// This is the standard WIN_CERTIFICATE header, where + /// wCertificateType is set to WIN_CERT_TYPE_UEFI_PKCS1_15. + /// + WIN_CERTIFICATE Hdr; + /// + /// This is the hashing algorithm which was performed on the + /// UEFI executable when creating the digital signature. + /// + EFI_GUID HashAlgorithm; + /// + /// The following is the actual digital signature. The + /// size of the signature is the same size as the key + /// (1024-bit key is 128 bytes) and can be determined by + /// subtracting the length of the other parts of this header + /// from the total length of the certificate as found in + /// Hdr.dwLength. + /// + /// UINT8 Signature[]; + /// +} WIN_CERTIFICATE_EFI_PKCS1_15; + +extern EFI_GUID gEfiCertTypeRsa2048Sha256Guid; + +#endif |