[efi] Update UEFI header files with latest version from TianoCore
[people/peper/gpxe.git] / src / include / gpxe / efi / Pi / PiHob.h
1 /** @file
2   HOB related definitions in PI.
3
4 Copyright (c) 2006 - 2010, 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 //
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 first three enumerations 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 //
258 // The rest of the settings describe capabilities
259 //
260 #define EFI_RESOURCE_ATTRIBUTE_SINGLE_BIT_ECC           0x00000008
261 #define EFI_RESOURCE_ATTRIBUTE_MULTIPLE_BIT_ECC         0x00000010
262 #define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_1           0x00000020
263 #define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_2           0x00000040
264 #define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED           0x00000080
265 #define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED          0x00000100
266 #define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED      0x00000200
267 #define EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE              0x00000400
268 #define EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE        0x00000800
269 #define EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE  0x00001000
270 #define EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE     0x00002000
271 #define EFI_RESOURCE_ATTRIBUTE_16_BIT_IO                0x00004000
272 #define EFI_RESOURCE_ATTRIBUTE_32_BIT_IO                0x00008000
273 #define EFI_RESOURCE_ATTRIBUTE_64_BIT_IO                0x00010000
274 #define EFI_RESOURCE_ATTRIBUTE_UNCACHED_EXPORTED        0x00020000
275
276 ///
277 /// Describes the resource properties of all fixed,
278 /// nonrelocatable resource ranges found on the processor
279 /// host bus during the HOB producer phase.
280 ///
281 typedef struct {
282   ///
283   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_RESOURCE_DESCRIPTOR.
284   ///
285   EFI_HOB_GENERIC_HEADER      Header;
286   ///
287   /// A GUID representing the owner of the resource. This GUID is used by HOB
288   /// consumer phase components to correlate device ownership of a resource.
289   ///
290   EFI_GUID                    Owner;
291   ///
292   /// The resource type enumeration as defined by EFI_RESOURCE_TYPE.
293   ///
294   EFI_RESOURCE_TYPE           ResourceType;
295   ///
296   /// Resource attributes as defined by EFI_RESOURCE_ATTRIBUTE_TYPE.
297   ///
298   EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute;
299   ///
300   /// The physical start address of the resource region.
301   ///
302   EFI_PHYSICAL_ADDRESS        PhysicalStart;
303   ///
304   /// The number of bytes of the resource region.
305   ///
306   UINT64                      ResourceLength;
307 } EFI_HOB_RESOURCE_DESCRIPTOR;
308
309 ///
310 /// Allows writers of executable content in the HOB producer phase to
311 /// maintain and manage HOBs with specific GUID.
312 ///
313 typedef struct {
314   ///
315   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION.
316   ///
317   EFI_HOB_GENERIC_HEADER      Header;
318   ///
319   /// A GUID that defines the contents of this HOB.
320   ///
321   EFI_GUID                    Name;
322   //
323   // Guid specific data goes here
324   //
325 } EFI_HOB_GUID_TYPE;
326
327 ///
328 /// Details the location of firmware volumes that contain firmware files.
329 ///
330 typedef struct {
331   ///
332   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV.
333   ///
334   EFI_HOB_GENERIC_HEADER Header;
335   ///
336   /// The physical memory-mapped base address of the firmware volume.
337   ///
338   EFI_PHYSICAL_ADDRESS   BaseAddress;
339   ///
340   /// The length in bytes of the firmware volume.
341   ///
342   UINT64                 Length;
343 } EFI_HOB_FIRMWARE_VOLUME;
344
345 ///
346 /// Details the location of a firmware volume that was extracted
347 /// from a file within another firmware volume.
348 ///
349 typedef struct {
350   ///
351   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV2.
352   ///
353   EFI_HOB_GENERIC_HEADER  Header;
354   ///
355   /// The physical memory-mapped base address of the firmware volume.
356   ///
357   EFI_PHYSICAL_ADDRESS    BaseAddress;
358   ///
359   /// The length in bytes of the firmware volume.
360   ///
361   UINT64                  Length;
362   ///
363   /// The name of the firmware volume.
364   ///
365   EFI_GUID                FvName;
366   ///
367   /// The name of the firmware file that contained this firmware volume.
368   ///
369   EFI_GUID                FileName;
370 } EFI_HOB_FIRMWARE_VOLUME2;
371
372
373 ///
374 /// Describes processor information, such as address space and I/O space capabilities.
375 ///
376 typedef struct {
377   ///
378   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_CPU.
379   ///
380   EFI_HOB_GENERIC_HEADER  Header;
381   ///
382   /// Identifies the maximum physical memory addressability of the processor.
383   ///
384   UINT8                   SizeOfMemorySpace;
385   ///
386   /// Identifies the maximum physical I/O addressability of the processor.
387   ///
388   UINT8                   SizeOfIoSpace;
389   ///
390   /// This field will always be set to zero.
391   ///
392   UINT8                   Reserved[6];
393 } EFI_HOB_CPU;
394
395
396 ///
397 /// Describes pool memory allocations.
398 ///
399 typedef struct {
400   ///
401   /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_POOL.
402   ///
403   EFI_HOB_GENERIC_HEADER  Header;
404 } EFI_HOB_MEMORY_POOL;
405
406 ///
407 /// Each UEFI capsule HOB details the location of a UEFI capsule. It includes a base address and length
408 /// which is based upon memory blocks with a EFI_CAPSULE_HEADER and the associated
409 /// CapsuleImageSize-based payloads. These HOB's shall be created by the PEI PI firmware
410 /// sometime after the UEFI UpdateCapsule service invocation with the
411 /// CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag set in the EFI_CAPSULE_HEADER.
412 ///
413 typedef struct {
414   ///
415   /// The HOB generic header where Header.HobType = EFI_HOB_TYPE_UEFI_CAPSULE.
416   ///
417   EFI_HOB_GENERIC_HEADER Header;
418
419   ///
420   /// The physical memory-mapped base address of an UEFI capsule. This value is set to
421   /// point to the base of the contiguous memory of the UEFI capsule.
422   /// The length of the contiguous memory in bytes.
423   ///
424   EFI_PHYSICAL_ADDRESS   BaseAddress;
425   UINT64                 Length;
426 } EFI_HOB_UEFI_CAPSULE;
427
428 ///
429 /// Union of all the possible HOB Types.
430 ///
431 typedef union {
432   EFI_HOB_GENERIC_HEADER              *Header;
433   EFI_HOB_HANDOFF_INFO_TABLE          *HandoffInformationTable;
434   EFI_HOB_MEMORY_ALLOCATION           *MemoryAllocation;
435   EFI_HOB_MEMORY_ALLOCATION_BSP_STORE *MemoryAllocationBspStore;
436   EFI_HOB_MEMORY_ALLOCATION_STACK     *MemoryAllocationStack;
437   EFI_HOB_MEMORY_ALLOCATION_MODULE    *MemoryAllocationModule;
438   EFI_HOB_RESOURCE_DESCRIPTOR         *ResourceDescriptor;
439   EFI_HOB_GUID_TYPE                   *Guid;
440   EFI_HOB_FIRMWARE_VOLUME             *FirmwareVolume;
441   EFI_HOB_FIRMWARE_VOLUME2            *FirmwareVolume2;
442   EFI_HOB_CPU                         *Cpu;
443   EFI_HOB_MEMORY_POOL                 *Pool;
444   EFI_HOB_UEFI_CAPSULE                *Capsule;
445   UINT8                               *Raw;
446 } EFI_PEI_HOB_POINTERS;
447
448
449 #endif