qemu/roms/ipxe/src/include/ipxe/efi/Pi/PiHob.h

   1 /** @file
   2   HOB related definitions in PI.
   3
   4 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials are licensed and made available under
   6 the terms and conditions of the BSD License that accompanies this distribution.
   7 The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php.
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13   @par Revision Reference:
  14   PI Version 1.0
  15
  16 **/
  17
  18 #ifndef __PI_HOB_H__
  19 #define __PI_HOB_H__
  20
  21 FILE_LICENCE ( BSD3 );
  22
  23 //
  24 // HobType of EFI_HOB_GENERIC_HEADER.
  25 //
  26 #define EFI_HOB_TYPE_HANDOFF              0x0001
  27 #define EFI_HOB_TYPE_MEMORY_ALLOCATION    0x0002
  28 #define EFI_HOB_TYPE_RESOURCE_DESCRIPTOR  0x0003
  29 #define EFI_HOB_TYPE_GUID_EXTENSION       0x0004
  30 #define EFI_HOB_TYPE_FV                   0x0005
  31 #define EFI_HOB_TYPE_CPU                  0x0006
  32 #define EFI_HOB_TYPE_MEMORY_POOL          0x0007
  33 #define EFI_HOB_TYPE_FV2                  0x0009
  34 #define EFI_HOB_TYPE_LOAD_PEIM_UNUSED     0x000A
  35 #define EFI_HOB_TYPE_UEFI_CAPSULE         0x000B
  36 #define EFI_HOB_TYPE_UNUSED               0xFFFE
  37 #define EFI_HOB_TYPE_END_OF_HOB_LIST      0xFFFF
  38
  39 ///
  40 /// Describes the format and size of the data inside the HOB.
  41 /// All HOBs must contain this generic HOB header.
  42 ///
  43 typedef struct {
  44   ///
  45   /// Identifies the HOB data structure type.
  46   ///
  47   UINT16    HobType;
  48   ///
  49   /// The length in bytes of the HOB.
  50   ///
  51   UINT16    HobLength;
  52   ///
  53   /// This field must always be set to zero.
  54   ///
  55   UINT32    Reserved;
  56 } EFI_HOB_GENERIC_HEADER;
  57
  58
  59 ///
  60 /// Value of version  in EFI_HOB_HANDOFF_INFO_TABLE.
  61 ///
  62 #define EFI_HOB_HANDOFF_TABLE_VERSION 0x0009
  63
  64 ///
  65 /// Contains general state information used by the HOB producer phase.
  66 /// This HOB must be the first one in the HOB list.
  67 ///
  68 typedef struct {
  69   ///
  70   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_HANDOFF.
  71   ///
  72   EFI_HOB_GENERIC_HEADER  Header;
  73   ///
  74   /// The version number pertaining to the PHIT HOB definition.
  75   /// This value is four bytes in length to provide an 8-byte aligned entry
  76   /// when it is combined with the 4-byte BootMode.
  77   ///
  78   UINT32                  Version;
  79   ///
  80   /// The system boot mode as determined during the HOB producer phase.
  81   ///
  82   EFI_BOOT_MODE           BootMode;
  83   ///
  84   /// The highest address location of memory that is allocated for use by the HOB producer
  85   /// phase. This address must be 4-KB aligned to meet page restrictions of UEFI.
  86   ///
  87   EFI_PHYSICAL_ADDRESS    EfiMemoryTop;
  88   ///
  89   /// The lowest address location of memory that is allocated for use by the HOB producer phase.
  90   ///
  91   EFI_PHYSICAL_ADDRESS    EfiMemoryBottom;
  92   ///
  93   /// The highest address location of free memory that is currently available
  94   /// for use by the HOB producer phase.
  95   ///
  96   EFI_PHYSICAL_ADDRESS    EfiFreeMemoryTop;
  97   ///
  98   /// The lowest address location of free memory that is available for use by the HOB producer phase.
  99   ///
 100   EFI_PHYSICAL_ADDRESS    EfiFreeMemoryBottom;
 101   ///
 102   /// The end of the HOB list.
 103   ///
 104   EFI_PHYSICAL_ADDRESS    EfiEndOfHobList;
 105 } EFI_HOB_HANDOFF_INFO_TABLE;
 106
 107 ///
 108 /// EFI_HOB_MEMORY_ALLOCATION_HEADER describes the
 109 /// various attributes of the logical memory allocation. The type field will be used for
 110 /// subsequent inclusion in the UEFI memory map.
 111 ///
 112 typedef struct {
 113   ///
 114   /// A GUID that defines the memory allocation region's type and purpose, as well as
 115   /// other fields within the memory allocation HOB. This GUID is used to define the
 116   /// additional data within the HOB that may be present for the memory allocation HOB.
 117   /// Type EFI_GUID is defined in InstallProtocolInterface() in the UEFI 2.0
 118   /// specification.
 119   ///
 120   EFI_GUID              Name;
 121
 122   ///
 123   /// The base address of memory allocated by this HOB. Type
 124   /// EFI_PHYSICAL_ADDRESS is defined in AllocatePages() in the UEFI 2.0
 125   /// specification.
 126   ///
 127   EFI_PHYSICAL_ADDRESS  MemoryBaseAddress;
 128
 129   ///
 130   /// The length in bytes of memory allocated by this HOB.
 131   ///
 132   UINT64                MemoryLength;
 133
 134   ///
 135   /// Defines the type of memory allocated by this HOB. The memory type definition
 136   /// follows the EFI_MEMORY_TYPE definition. Type EFI_MEMORY_TYPE is defined
 137   /// in AllocatePages() in the UEFI 2.0 specification.
 138   ///
 139   EFI_MEMORY_TYPE       MemoryType;
 140
 141   ///
 142   /// Padding for Itanium processor family
 143   ///
 144   UINT8                 Reserved[4];
 145 } EFI_HOB_MEMORY_ALLOCATION_HEADER;
 146
 147 ///
 148 /// Describes all memory ranges used during the HOB producer
 149 /// phase that exist outside the HOB list. This HOB type
 150 /// describes how memory is used, not the physical attributes of memory.
 151 ///
 152 typedef struct {
 153   ///
 154   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
 155   ///
 156   EFI_HOB_GENERIC_HEADER            Header;
 157   ///
 158   /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
 159   /// various attributes of the logical memory allocation.
 160   ///
 161   EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
 162   //
 163   // Additional data pertaining to the "Name" Guid memory
 164   // may go here.
 165   //
 166 } EFI_HOB_MEMORY_ALLOCATION;
 167
 168
 169 ///
 170 /// Describes the memory stack that is produced by the HOB producer
 171 /// phase and upon which all post-memory-installed executable
 172 /// content in the HOB producer phase is executing.
 173 ///
 174 typedef struct {
 175   ///
 176   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
 177   ///
 178   EFI_HOB_GENERIC_HEADER            Header;
 179   ///
 180   /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
 181   /// various attributes of the logical memory allocation.
 182   ///
 183   EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
 184 } EFI_HOB_MEMORY_ALLOCATION_STACK;
 185
 186 ///
 187 /// Defines the location of the boot-strap
 188 /// processor (BSP) BSPStore ("Backing Store Pointer Store").
 189 /// This HOB is valid for the Itanium processor family only
 190 /// register overflow store.
 191 ///
 192 typedef struct {
 193   ///
 194   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
 195   ///
 196   EFI_HOB_GENERIC_HEADER            Header;
 197   ///
 198   /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
 199   /// various attributes of the logical memory allocation.
 200   ///
 201   EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
 202 } EFI_HOB_MEMORY_ALLOCATION_BSP_STORE;
 203
 204 ///
 205 /// Defines the location and entry point of the HOB consumer phase.
 206 ///
 207 typedef struct {
 208   ///
 209   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
 210   ///
 211   EFI_HOB_GENERIC_HEADER            Header;
 212   ///
 213   /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
 214   /// various attributes of the logical memory allocation.
 215   ///
 216   EFI_HOB_MEMORY_ALLOCATION_HEADER  MemoryAllocationHeader;
 217   ///
 218   /// The GUID specifying the values of the firmware file system name
 219   /// that contains the HOB consumer phase component.
 220   ///
 221   EFI_GUID                          ModuleName;
 222   ///
 223   /// The address of the memory-mapped firmware volume
 224   /// that contains the HOB consumer phase firmware file.
 225   ///
 226   EFI_PHYSICAL_ADDRESS              EntryPoint;
 227 } EFI_HOB_MEMORY_ALLOCATION_MODULE;
 228
 229 ///
 230 /// The resource type.
 231 ///
 232 typedef UINT32 EFI_RESOURCE_TYPE;
 233
 234 //
 235 // Value of ResourceType in EFI_HOB_RESOURCE_DESCRIPTOR.
 236 //
 237 #define EFI_RESOURCE_SYSTEM_MEMORY          0x00000000
 238 #define EFI_RESOURCE_MEMORY_MAPPED_IO       0x00000001
 239 #define EFI_RESOURCE_IO                     0x00000002
 240 #define EFI_RESOURCE_FIRMWARE_DEVICE        0x00000003
 241 #define EFI_RESOURCE_MEMORY_MAPPED_IO_PORT  0x00000004
 242 #define EFI_RESOURCE_MEMORY_RESERVED        0x00000005
 243 #define EFI_RESOURCE_IO_RESERVED            0x00000006
 244 #define EFI_RESOURCE_MAX_MEMORY_TYPE        0x00000007
 245
 246 ///
 247 /// A type of recount attribute type.
 248 ///
 249 typedef UINT32 EFI_RESOURCE_ATTRIBUTE_TYPE;
 250
 251 //
 252 // These types can be ORed together as needed.
 253 //
 254 // The following attributes are used to describe settings
 255 //
 256 #define EFI_RESOURCE_ATTRIBUTE_PRESENT                  0x00000001
 257 #define EFI_RESOURCE_ATTRIBUTE_INITIALIZED              0x00000002
 258 #define EFI_RESOURCE_ATTRIBUTE_TESTED                   0x00000004
 259 #define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED           0x00000080
 260 #define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED          0x00000100
 261 #define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED      0x00000200
 262 //
 263 // The rest of the attributes are used to describe capabilities
 264 //
 265 #define EFI_RESOURCE_ATTRIBUTE_SINGLE_BIT_ECC           0x00000008
 266 #define EFI_RESOURCE_ATTRIBUTE_MULTIPLE_BIT_ECC         0x00000010
 267 #define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_1           0x00000020
 268 #define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_2           0x00000040
 269 #define EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE              0x00000400
 270 #define EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE        0x00000800
 271 #define EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE  0x00001000
 272 #define EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE     0x00002000
 273 #define EFI_RESOURCE_ATTRIBUTE_16_BIT_IO                0x00004000
 274 #define EFI_RESOURCE_ATTRIBUTE_32_BIT_IO                0x00008000
 275 #define EFI_RESOURCE_ATTRIBUTE_64_BIT_IO                0x00010000
 276 #define EFI_RESOURCE_ATTRIBUTE_UNCACHED_EXPORTED        0x00020000
 277 #define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTABLE         0x00100000
 278 #define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTABLE        0x00200000
 279 #define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTABLE    0x00400000
 280
 281 ///
 282 /// Describes the resource properties of all fixed,
 283 /// nonrelocatable resource ranges found on the processor
 284 /// host bus during the HOB producer phase.
 285 ///
 286 typedef struct {
 287   ///
 288   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_RESOURCE_DESCRIPTOR.
 289   ///
 290   EFI_HOB_GENERIC_HEADER      Header;
 291   ///
 292   /// A GUID representing the owner of the resource. This GUID is used by HOB
 293   /// consumer phase components to correlate device ownership of a resource.
 294   ///
 295   EFI_GUID                    Owner;
 296   ///
 297   /// The resource type enumeration as defined by EFI_RESOURCE_TYPE.
 298   ///
 299   EFI_RESOURCE_TYPE           ResourceType;
 300   ///
 301   /// Resource attributes as defined by EFI_RESOURCE_ATTRIBUTE_TYPE.
 302   ///
 303   EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute;
 304   ///
 305   /// The physical start address of the resource region.
 306   ///
 307   EFI_PHYSICAL_ADDRESS        PhysicalStart;
 308   ///
 309   /// The number of bytes of the resource region.
 310   ///
 311   UINT64                      ResourceLength;
 312 } EFI_HOB_RESOURCE_DESCRIPTOR;
 313
 314 ///
 315 /// Allows writers of executable content in the HOB producer phase to
 316 /// maintain and manage HOBs with specific GUID.
 317 ///
 318 typedef struct {
 319   ///
 320   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION.
 321   ///
 322   EFI_HOB_GENERIC_HEADER      Header;
 323   ///
 324   /// A GUID that defines the contents of this HOB.
 325   ///
 326   EFI_GUID                    Name;
 327   //
 328   // Guid specific data goes here
 329   //
 330 } EFI_HOB_GUID_TYPE;
 331
 332 ///
 333 /// Details the location of firmware volumes that contain firmware files.
 334 ///
 335 typedef struct {
 336   ///
 337   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV.
 338   ///
 339   EFI_HOB_GENERIC_HEADER Header;
 340   ///
 341   /// The physical memory-mapped base address of the firmware volume.
 342   ///
 343   EFI_PHYSICAL_ADDRESS   BaseAddress;
 344   ///
 345   /// The length in bytes of the firmware volume.
 346   ///
 347   UINT64                 Length;
 348 } EFI_HOB_FIRMWARE_VOLUME;
 349
 350 ///
 351 /// Details the location of a firmware volume that was extracted
 352 /// from a file within another firmware volume.
 353 ///
 354 typedef struct {
 355   ///
 356   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV2.
 357   ///
 358   EFI_HOB_GENERIC_HEADER  Header;
 359   ///
 360   /// The physical memory-mapped base address of the firmware volume.
 361   ///
 362   EFI_PHYSICAL_ADDRESS    BaseAddress;
 363   ///
 364   /// The length in bytes of the firmware volume.
 365   ///
 366   UINT64                  Length;
 367   ///
 368   /// The name of the firmware volume.
 369   ///
 370   EFI_GUID                FvName;
 371   ///
 372   /// The name of the firmware file that contained this firmware volume.
 373   ///
 374   EFI_GUID                FileName;
 375 } EFI_HOB_FIRMWARE_VOLUME2;
 376
 377
 378 ///
 379 /// Describes processor information, such as address space and I/O space capabilities.
 380 ///
 381 typedef struct {
 382   ///
 383   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_CPU.
 384   ///
 385   EFI_HOB_GENERIC_HEADER  Header;
 386   ///
 387   /// Identifies the maximum physical memory addressability of the processor.
 388   ///
 389   UINT8                   SizeOfMemorySpace;
 390   ///
 391   /// Identifies the maximum physical I/O addressability of the processor.
 392   ///
 393   UINT8                   SizeOfIoSpace;
 394   ///
 395   /// This field will always be set to zero.
 396   ///
 397   UINT8                   Reserved[6];
 398 } EFI_HOB_CPU;
 399
 400
 401 ///
 402 /// Describes pool memory allocations.
 403 ///
 404 typedef struct {
 405   ///
 406   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_POOL.
 407   ///
 408   EFI_HOB_GENERIC_HEADER  Header;
 409 } EFI_HOB_MEMORY_POOL;
 410
 411 ///
 412 /// Each UEFI capsule HOB details the location of a UEFI capsule. It includes a base address and length
 413 /// which is based upon memory blocks with a EFI_CAPSULE_HEADER and the associated
 414 /// CapsuleImageSize-based payloads. These HOB's shall be created by the PEI PI firmware
 415 /// sometime after the UEFI UpdateCapsule service invocation with the
 416 /// CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag set in the EFI_CAPSULE_HEADER.
 417 ///
 418 typedef struct {
 419   ///
 420   /// The HOB generic header where Header.HobType = EFI_HOB_TYPE_UEFI_CAPSULE.
 421   ///
 422   EFI_HOB_GENERIC_HEADER Header;
 423
 424   ///
 425   /// The physical memory-mapped base address of an UEFI capsule. This value is set to
 426   /// point to the base of the contiguous memory of the UEFI capsule.
 427   /// The length of the contiguous memory in bytes.
 428   ///
 429   EFI_PHYSICAL_ADDRESS   BaseAddress;
 430   UINT64                 Length;
 431 } EFI_HOB_UEFI_CAPSULE;
 432
 433 ///
 434 /// Union of all the possible HOB Types.
 435 ///
 436 typedef union {
 437   EFI_HOB_GENERIC_HEADER              *Header;
 438   EFI_HOB_HANDOFF_INFO_TABLE          *HandoffInformationTable;
 439   EFI_HOB_MEMORY_ALLOCATION           *MemoryAllocation;
 440   EFI_HOB_MEMORY_ALLOCATION_BSP_STORE *MemoryAllocationBspStore;
 441   EFI_HOB_MEMORY_ALLOCATION_STACK     *MemoryAllocationStack;
 442   EFI_HOB_MEMORY_ALLOCATION_MODULE    *MemoryAllocationModule;
 443   EFI_HOB_RESOURCE_DESCRIPTOR         *ResourceDescriptor;
 444   EFI_HOB_GUID_TYPE                   *Guid;
 445   EFI_HOB_FIRMWARE_VOLUME             *FirmwareVolume;
 446   EFI_HOB_FIRMWARE_VOLUME2            *FirmwareVolume2;
 447   EFI_HOB_CPU                         *Cpu;
 448   EFI_HOB_MEMORY_POOL                 *Pool;
 449   EFI_HOB_UEFI_CAPSULE                *Capsule;
 450   UINT8                               *Raw;
 451 } EFI_PEI_HOB_POINTERS;
 452
 453
 454 #endif