FreeBSD/Linux Kernel Cross Reference
sys/contrib/edk2/Include/Uefi/UefiMultiPhase.h

     /** @file
       This includes some definitions introduced in UEFI that will be used in both PEI and DXE phases.
     
     Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
     SPDX-License-Identifier: BSD-2-Clause-Patent
     
     **/
     
     #ifndef __UEFI_MULTIPHASE_H__
    #define __UEFI_MULTIPHASE_H__
    
    ///
    /// Attributes of variable.
    ///
    #define EFI_VARIABLE_NON_VOLATILE                            0x00000001
    #define EFI_VARIABLE_BOOTSERVICE_ACCESS                      0x00000002
    #define EFI_VARIABLE_RUNTIME_ACCESS                          0x00000004
    ///
    /// This attribute is identified by the mnemonic 'HR'
    /// elsewhere in this specification.
    ///
    #define EFI_VARIABLE_HARDWARE_ERROR_RECORD                   0x00000008
    ///
    /// Attributes of Authenticated Variable
    ///
    #define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS   0x00000020
    #define EFI_VARIABLE_APPEND_WRITE                            0x00000040
    ///
    /// NOTE: EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS is deprecated and should be considered reserved.
    ///
    #define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS              0x00000010
    
    #ifndef VFRCOMPILE
    #include <Guid/WinCertificate.h>
    ///
    /// Enumeration of memory types introduced in UEFI.
    ///
    typedef enum {
      ///
      /// Not used.
      ///
      EfiReservedMemoryType,
      ///
      /// The code portions of a loaded application.
      /// (Note that UEFI OS loaders are UEFI applications.)
      ///
      EfiLoaderCode,
      ///
      /// The data portions of a loaded application and the default data allocation
      /// type used by an application to allocate pool memory.
      ///
      EfiLoaderData,
      ///
      /// The code portions of a loaded Boot Services Driver.
      ///
      EfiBootServicesCode,
      ///
      /// The data portions of a loaded Boot Serves Driver, and the default data
      /// allocation type used by a Boot Services Driver to allocate pool memory.
      ///
      EfiBootServicesData,
      ///
      /// The code portions of a loaded Runtime Services Driver.
      ///
      EfiRuntimeServicesCode,
      ///
      /// The data portions of a loaded Runtime Services Driver and the default
      /// data allocation type used by a Runtime Services Driver to allocate pool memory.
      ///
      EfiRuntimeServicesData,
      ///
      /// Free (unallocated) memory.
      ///
      EfiConventionalMemory,
      ///
      /// Memory in which errors have been detected.
      ///
      EfiUnusableMemory,
      ///
      /// Memory that holds the ACPI tables.
      ///
      EfiACPIReclaimMemory,
      ///
      /// Address space reserved for use by the firmware.
      ///
      EfiACPIMemoryNVS,
      ///
      /// Used by system firmware to request that a memory-mapped IO region
      /// be mapped by the OS to a virtual address so it can be accessed by EFI runtime services.
      ///
      EfiMemoryMappedIO,
      ///
      /// System memory-mapped IO region that is used to translate memory
      /// cycles to IO cycles by the processor.
      ///
      EfiMemoryMappedIOPortSpace,
      ///
      /// Address space reserved by the firmware for code that is part of the processor.
      ///
     EfiPalCode,
     ///
     /// A memory region that operates as EfiConventionalMemory,
     /// however it happens to also support byte-addressable non-volatility.
     ///
     EfiPersistentMemory,
     EfiMaxMemoryType
   } EFI_MEMORY_TYPE;
   
   ///
   /// Enumeration of reset types.
   ///
   typedef enum {
     ///
     /// Used to induce a system-wide reset. This sets all circuitry within the
     /// system to its initial state.  This type of reset is asynchronous to system
     /// operation and operates withgout regard to cycle boundaries.  EfiColdReset
     /// is tantamount to a system power cycle.
     ///
     EfiResetCold,
     ///
     /// Used to induce a system-wide initialization. The processors are set to their
     /// initial state, and pending cycles are not corrupted.  If the system does
     /// not support this reset type, then an EfiResetCold must be performed.
     ///
     EfiResetWarm,
     ///
     /// Used to induce an entry into a power state equivalent to the ACPI G2/S5 or G3
     /// state.  If the system does not support this reset type, then when the system
     /// is rebooted, it should exhibit the EfiResetCold attributes.
     ///
     EfiResetShutdown,
     ///
     /// Used to induce a system-wide reset. The exact type of the reset is defined by
     /// the EFI_GUID that follows the Null-terminated Unicode string passed into
     /// ResetData. If the platform does not recognize the EFI_GUID in ResetData the
     /// platform must pick a supported reset type to perform. The platform may
     /// optionally log the parameters from any non-normal reset that occurs.
     ///
     EfiResetPlatformSpecific
   } EFI_RESET_TYPE;
   
   ///
   /// Data structure that precedes all of the standard EFI table types.
   ///
   typedef struct {
     ///
     /// A 64-bit signature that identifies the type of table that follows.
     /// Unique signatures have been generated for the EFI System Table,
     /// the EFI Boot Services Table, and the EFI Runtime Services Table.
     ///
     UINT64  Signature;
     ///
     /// The revision of the EFI Specification to which this table
     /// conforms. The upper 16 bits of this field contain the major
     /// revision value, and the lower 16 bits contain the minor revision
     /// value. The minor revision values are limited to the range of 00..99.
     ///
     UINT32  Revision;
     ///
     /// The size, in bytes, of the entire table including the EFI_TABLE_HEADER.
     ///
     UINT32  HeaderSize;
     ///
     /// The 32-bit CRC for the entire table. This value is computed by
     /// setting this field to 0, and computing the 32-bit CRC for HeaderSize bytes.
     ///
     UINT32  CRC32;
     ///
     /// Reserved field that must be set to 0.
     ///
     UINT32  Reserved;
   } EFI_TABLE_HEADER;
   
   ///
   /// AuthInfo is a WIN_CERTIFICATE using the wCertificateType
   /// WIN_CERTIFICATE_UEFI_GUID and the CertType
   /// EFI_CERT_TYPE_RSA2048_SHA256_GUID. If the attribute specifies
   /// authenticated access, then the Data buffer should begin with an
   /// authentication descriptor prior to the data payload and DataSize
   /// should reflect the the data.and descriptor size. The caller
   /// shall digest the Monotonic Count value and the associated data
   /// for the variable update using the SHA-256 1-way hash algorithm.
   /// The ensuing the 32-byte digest will be signed using the private
   /// key associated w/ the public/private 2048-bit RSA key-pair. The
   /// WIN_CERTIFICATE shall be used to describe the signature of the
   /// Variable data *Data. In addition, the signature will also
   /// include the MonotonicCount value to guard against replay attacks.
   ///
   typedef struct {
     ///
     /// Included in the signature of
     /// AuthInfo.Used to ensure freshness/no
     /// replay. Incremented during each
     /// "Write" access.
     ///
     UINT64                      MonotonicCount;
     ///
     /// Provides the authorization for the variable
     /// access. It is a signature across the
     /// variable data and the  Monotonic Count
     /// value. Caller uses Private key that is
     /// associated with a public key that has been
     /// provisioned via the key exchange.
     ///
     WIN_CERTIFICATE_UEFI_GUID   AuthInfo;
   } EFI_VARIABLE_AUTHENTICATION;
   
   ///
   /// When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is
   /// set, then the Data buffer shall begin with an instance of a complete (and serialized)
   /// EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new
   /// variable value and DataSize shall reflect the combined size of the descriptor and the new
   /// variable value. The authentication descriptor is not part of the variable data and is not
   /// returned by subsequent calls to GetVariable().
   ///
   typedef struct {
     ///
     /// For the TimeStamp value, components Pad1, Nanosecond, TimeZone, Daylight and
     /// Pad2 shall be set to 0. This means that the time shall always be expressed in GMT.
     ///
     EFI_TIME                    TimeStamp;
     ///
     /// Only a CertType of  EFI_CERT_TYPE_PKCS7_GUID is accepted.
     ///
     WIN_CERTIFICATE_UEFI_GUID   AuthInfo;
    } EFI_VARIABLE_AUTHENTICATION_2;
   #endif // VFRCOMPILE
   
   #endif

Cache object: 8bf46c15f7e3cefccefe75303d07f325