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