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.6 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_MAX_MEMORY_TYPE 0x00000007 236 237 /// 238 /// A type of recount attribute type. 239 /// 240 typedef UINT32 EFI_RESOURCE_ATTRIBUTE_TYPE; 241 242 // 243 // These types can be ORed together as needed. 244 // 245 // The following attributes are used to describe settings 246 // 247 #define EFI_RESOURCE_ATTRIBUTE_PRESENT 0x00000001 248 #define EFI_RESOURCE_ATTRIBUTE_INITIALIZED 0x00000002 249 #define EFI_RESOURCE_ATTRIBUTE_TESTED 0x00000004 250 #define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED 0x00000080 251 // 252 // This is typically used as memory cacheability attribute today. 253 // NOTE: Since PI spec 1.4, please use EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTED 254 // as Physical write protected attribute, and EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED 255 // means Memory cacheability attribute: The memory supports being programmed with 256 // a writeprotected cacheable attribute. 257 // 258 #define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED 0x00000100 259 #define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED 0x00000200 260 #define EFI_RESOURCE_ATTRIBUTE_PERSISTENT 0x00800000 261 // 262 // The rest of the attributes are used to describe capabilities 263 // 264 #define EFI_RESOURCE_ATTRIBUTE_SINGLE_BIT_ECC 0x00000008 265 #define EFI_RESOURCE_ATTRIBUTE_MULTIPLE_BIT_ECC 0x00000010 266 #define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_1 0x00000020 267 #define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_2 0x00000040 268 #define EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE 0x00000400 269 #define EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE 0x00000800 270 #define EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE 0x00001000 271 #define EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE 0x00002000 272 #define EFI_RESOURCE_ATTRIBUTE_16_BIT_IO 0x00004000 273 #define EFI_RESOURCE_ATTRIBUTE_32_BIT_IO 0x00008000 274 #define EFI_RESOURCE_ATTRIBUTE_64_BIT_IO 0x00010000 275 #define EFI_RESOURCE_ATTRIBUTE_UNCACHED_EXPORTED 0x00020000 276 #define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTABLE 0x00100000 277 // 278 // This is typically used as memory cacheability attribute today. 279 // NOTE: Since PI spec 1.4, please use EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTABLE 280 // as Memory capability attribute: The memory supports being protected from processor 281 // writes, and EFI_RESOURCE_ATTRIBUTE_WRITE_PROTEC TABLE means Memory cacheability attribute: 282 // The memory supports being programmed with a writeprotected cacheable attribute. 283 // 284 #define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTABLE 0x00200000 285 #define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTABLE 0x00400000 286 #define EFI_RESOURCE_ATTRIBUTE_PERSISTABLE 0x01000000 287 288 #define EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTED 0x00040000 289 #define EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTABLE 0x00080000 290 291 // 292 // Physical memory relative reliability attribute. This 293 // memory provides higher reliability relative to other 294 // memory in the system. If all memory has the same 295 // reliability, then this bit is not used. 296 // 297 #define EFI_RESOURCE_ATTRIBUTE_MORE_RELIABLE 0x02000000 298 299 /// 300 /// Describes the resource properties of all fixed, 301 /// nonrelocatable resource ranges found on the processor 302 /// host bus during the HOB producer phase. 303 /// 304 typedef struct { 305 /// 306 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_RESOURCE_DESCRIPTOR. 307 /// 308 EFI_HOB_GENERIC_HEADER Header; 309 /// 310 /// A GUID representing the owner of the resource. This GUID is used by HOB 311 /// consumer phase components to correlate device ownership of a resource. 312 /// 313 EFI_GUID Owner; 314 /// 315 /// The resource type enumeration as defined by EFI_RESOURCE_TYPE. 316 /// 317 EFI_RESOURCE_TYPE ResourceType; 318 /// 319 /// Resource attributes as defined by EFI_RESOURCE_ATTRIBUTE_TYPE. 320 /// 321 EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute; 322 /// 323 /// The physical start address of the resource region. 324 /// 325 EFI_PHYSICAL_ADDRESS PhysicalStart; 326 /// 327 /// The number of bytes of the resource region. 328 /// 329 UINT64 ResourceLength; 330 } EFI_HOB_RESOURCE_DESCRIPTOR; 331 332 /// 333 /// Allows writers of executable content in the HOB producer phase to 334 /// maintain and manage HOBs with specific GUID. 335 /// 336 typedef struct { 337 /// 338 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION. 339 /// 340 EFI_HOB_GENERIC_HEADER Header; 341 /// 342 /// A GUID that defines the contents of this HOB. 343 /// 344 EFI_GUID Name; 345 // 346 // Guid specific data goes here 347 // 348 } EFI_HOB_GUID_TYPE; 349 350 /// 351 /// Details the location of firmware volumes that contain firmware files. 352 /// 353 typedef struct { 354 /// 355 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV. 356 /// 357 EFI_HOB_GENERIC_HEADER Header; 358 /// 359 /// The physical memory-mapped base address of the firmware volume. 360 /// 361 EFI_PHYSICAL_ADDRESS BaseAddress; 362 /// 363 /// The length in bytes of the firmware volume. 364 /// 365 UINT64 Length; 366 } EFI_HOB_FIRMWARE_VOLUME; 367 368 /// 369 /// Details the location of a firmware volume that was extracted 370 /// from a file within another firmware volume. 371 /// 372 typedef struct { 373 /// 374 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV2. 375 /// 376 EFI_HOB_GENERIC_HEADER Header; 377 /// 378 /// The physical memory-mapped base address of the firmware volume. 379 /// 380 EFI_PHYSICAL_ADDRESS BaseAddress; 381 /// 382 /// The length in bytes of the firmware volume. 383 /// 384 UINT64 Length; 385 /// 386 /// The name of the firmware volume. 387 /// 388 EFI_GUID FvName; 389 /// 390 /// The name of the firmware file that contained this firmware volume. 391 /// 392 EFI_GUID FileName; 393 } EFI_HOB_FIRMWARE_VOLUME2; 394 395 /// 396 /// Details the location of a firmware volume that was extracted 397 /// from a file within another firmware volume. 398 /// 399 typedef struct { 400 /// 401 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV3. 402 /// 403 EFI_HOB_GENERIC_HEADER Header; 404 /// 405 /// The physical memory-mapped base address of the firmware volume. 406 /// 407 EFI_PHYSICAL_ADDRESS BaseAddress; 408 /// 409 /// The length in bytes of the firmware volume. 410 /// 411 UINT64 Length; 412 /// 413 /// The authentication status. 414 /// 415 UINT32 AuthenticationStatus; 416 /// 417 /// TRUE if the FV was extracted as a file within another firmware volume. 418 /// FALSE otherwise. 419 /// 420 BOOLEAN ExtractedFv; 421 /// 422 /// The name of the firmware volume. 423 /// Valid only if IsExtractedFv is TRUE. 424 /// 425 EFI_GUID FvName; 426 /// 427 /// The name of the firmware file that contained this firmware volume. 428 /// Valid only if IsExtractedFv is TRUE. 429 /// 430 EFI_GUID FileName; 431 } EFI_HOB_FIRMWARE_VOLUME3; 432 433 /// 434 /// Describes processor information, such as address space and I/O space capabilities. 435 /// 436 typedef struct { 437 /// 438 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_CPU. 439 /// 440 EFI_HOB_GENERIC_HEADER Header; 441 /// 442 /// Identifies the maximum physical memory addressability of the processor. 443 /// 444 UINT8 SizeOfMemorySpace; 445 /// 446 /// Identifies the maximum physical I/O addressability of the processor. 447 /// 448 UINT8 SizeOfIoSpace; 449 /// 450 /// This field will always be set to zero. 451 /// 452 UINT8 Reserved[6]; 453 } EFI_HOB_CPU; 454 455 /// 456 /// Describes pool memory allocations. 457 /// 458 typedef struct { 459 /// 460 /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_POOL. 461 /// 462 EFI_HOB_GENERIC_HEADER Header; 463 } EFI_HOB_MEMORY_POOL; 464 465 /// 466 /// Each UEFI capsule HOB details the location of a UEFI capsule. It includes a base address and length 467 /// which is based upon memory blocks with a EFI_CAPSULE_HEADER and the associated 468 /// CapsuleImageSize-based payloads. These HOB's shall be created by the PEI PI firmware 469 /// sometime after the UEFI UpdateCapsule service invocation with the 470 /// CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag set in the EFI_CAPSULE_HEADER. 471 /// 472 typedef struct { 473 /// 474 /// The HOB generic header where Header.HobType = EFI_HOB_TYPE_UEFI_CAPSULE. 475 /// 476 EFI_HOB_GENERIC_HEADER Header; 477 478 /// 479 /// The physical memory-mapped base address of an UEFI capsule. This value is set to 480 /// point to the base of the contiguous memory of the UEFI capsule. 481 /// The length of the contiguous memory in bytes. 482 /// 483 EFI_PHYSICAL_ADDRESS BaseAddress; 484 UINT64 Length; 485 } EFI_HOB_UEFI_CAPSULE; 486 487 /// 488 /// Union of all the possible HOB Types. 489 /// 490 typedef union { 491 EFI_HOB_GENERIC_HEADER *Header; 492 EFI_HOB_HANDOFF_INFO_TABLE *HandoffInformationTable; 493 EFI_HOB_MEMORY_ALLOCATION *MemoryAllocation; 494 EFI_HOB_MEMORY_ALLOCATION_BSP_STORE *MemoryAllocationBspStore; 495 EFI_HOB_MEMORY_ALLOCATION_STACK *MemoryAllocationStack; 496 EFI_HOB_MEMORY_ALLOCATION_MODULE *MemoryAllocationModule; 497 EFI_HOB_RESOURCE_DESCRIPTOR *ResourceDescriptor; 498 EFI_HOB_GUID_TYPE *Guid; 499 EFI_HOB_FIRMWARE_VOLUME *FirmwareVolume; 500 EFI_HOB_FIRMWARE_VOLUME2 *FirmwareVolume2; 501 EFI_HOB_FIRMWARE_VOLUME3 *FirmwareVolume3; 502 EFI_HOB_CPU *Cpu; 503 EFI_HOB_MEMORY_POOL *Pool; 504 EFI_HOB_UEFI_CAPSULE *Capsule; 505 UINT8 *Raw; 506 } EFI_PEI_HOB_POINTERS; 507 508 #endif 509