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