]> git.proxmox.com Git - mirror_edk2.git/blob - DuetPkg/DxeIpl/HobGeneration.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update the copyright notice format
[mirror_edk2.git] / DuetPkg / DxeIpl / HobGeneration.c
1 /** @file
2
3 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
4 This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13 HobGeneration.c
14
15 Abstract:
16
17 Revision History:
18
19 **/
20 #include "DxeIpl.h"
21 #include "HobGeneration.h"
22 #include "PpisNeededByDxeCore.h"
23 #include "FlashLayout.h"
24 #include "Debug.h"
25
26 #define EFI_DXE_FILE_GUID \
27 { 0xb1644c1a, 0xc16a, 0x4c5b, {0x88, 0xde, 0xea, 0xfb, 0xa9, 0x7e, 0x74, 0xd8 }}
28
29 #define EFI_CPUID_EXTENDED_FUNCTION 0x80000000
30 #define CPUID_EXTENDED_ADD_SIZE 0x80000008
31
32 HOB_TEMPLATE gHobTemplate = {
33 { // Phit
34 { // Header
35 EFI_HOB_TYPE_HANDOFF, // HobType
36 sizeof (EFI_HOB_HANDOFF_INFO_TABLE), // HobLength
37 0 // Reserved
38 },
39 EFI_HOB_HANDOFF_TABLE_VERSION, // Version
40 BOOT_WITH_FULL_CONFIGURATION, // BootMode
41 0, // EfiMemoryTop
42 0, // EfiMemoryBottom
43 0, // EfiFreeMemoryTop
44 0, // EfiFreeMemoryBottom
45 0 // EfiEndOfHobList
46 },
47 { // Bfv
48 {
49 EFI_HOB_TYPE_FV, // HobType
50 sizeof (EFI_HOB_FIRMWARE_VOLUME), // HobLength
51 0 // Reserved
52 },
53 0, // BaseAddress
54 0 // Length
55 },
56 { // BfvResource
57 {
58 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
59 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
60 0 // Reserved
61 },
62 {
63 0 // Owner Guid
64 },
65 EFI_RESOURCE_FIRMWARE_DEVICE, // ResourceType
66 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
67 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
68 EFI_RESOURCE_ATTRIBUTE_TESTED |
69 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), // ResourceAttribute
70 0, // PhysicalStart
71 0 // ResourceLength
72 },
73 { // Cpu
74 { // Header
75 EFI_HOB_TYPE_CPU, // HobType
76 sizeof (EFI_HOB_CPU), // HobLength
77 0 // Reserved
78 },
79 52, // SizeOfMemorySpace - Architecture Max
80 16, // SizeOfIoSpace,
81 {
82 0, 0, 0, 0, 0, 0 // Reserved[6]
83 }
84 },
85 { // Stack HOB
86 { // header
87 EFI_HOB_TYPE_MEMORY_ALLOCATION, // Hob type
88 sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK), // Hob size
89 0 // reserved
90 },
91 {
92 EFI_HOB_MEMORY_ALLOC_STACK_GUID,
93 0x0, // EFI_PHYSICAL_ADDRESS MemoryBaseAddress;
94 0x0, // UINT64 MemoryLength;
95 EfiBootServicesData, // EFI_MEMORY_TYPE MemoryType;
96 {0, 0, 0, 0} // Reserved Reserved[4];
97 }
98 },
99 { // MemoryAllocation for HOB's & Images
100 {
101 EFI_HOB_TYPE_MEMORY_ALLOCATION, // HobType
102 sizeof (EFI_HOB_MEMORY_ALLOCATION), // HobLength
103 0 // Reserved
104 },
105 {
106 {
107 0, //EFI_HOB_MEMORY_ALLOC_MODULE_GUID // Name
108 },
109 0x0, // EFI_PHYSICAL_ADDRESS MemoryBaseAddress;
110 0x0, // UINT64 MemoryLength;
111 EfiBootServicesData, // EFI_MEMORY_TYPE MemoryType;
112 {
113 0, 0, 0, 0 // Reserved Reserved[4];
114 }
115 }
116 },
117 { // MemoryFreeUnder1MB for unused memory that DXE core will claim
118 {
119 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
120 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
121 0 // Reserved
122 },
123 {
124 0 // Owner Guid
125 },
126 EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType
127 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
128 EFI_RESOURCE_ATTRIBUTE_TESTED |
129 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
130 EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
131 EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
132 EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
133 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE),
134 0x0, // PhysicalStart
135 0 // ResourceLength
136 },
137 { // MemoryFreeAbove1MB for unused memory that DXE core will claim
138 {
139 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
140 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
141 0 // Reserved
142 },
143 {
144 0 // Owner Guid
145 },
146 EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType
147 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
148 EFI_RESOURCE_ATTRIBUTE_TESTED |
149 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
150 EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
151 EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
152 EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
153 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE),
154 0x0, // PhysicalStart
155 0 // ResourceLength
156 },
157 { // MemoryFreeAbove4GB for unused memory that DXE core will claim
158 {
159 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
160 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
161 0 // Reserved
162 },
163 {
164 0 // Owner Guid
165 },
166 EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType
167 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
168 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
169 EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
170 EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
171 EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
172 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE),
173 0x0, // PhysicalStart
174 0 // ResourceLength
175 },
176 { // Memory Allocation Module for DxeCore
177 { // header
178 EFI_HOB_TYPE_MEMORY_ALLOCATION, // Hob type
179 sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE), // Hob size
180 0 // reserved
181 },
182 {
183 EFI_HOB_MEMORY_ALLOC_MODULE_GUID,
184 0x0, // EFI_PHYSICAL_ADDRESS MemoryBaseAddress;
185 0x0, // UINT64 MemoryLength;
186 EfiBootServicesCode, // EFI_MEMORY_TYPE MemoryType;
187 {
188 0, 0, 0, 0 // UINT8 Reserved[4];
189 },
190 },
191 EFI_DXE_FILE_GUID,
192 0x0 // EFI_PHYSICAL_ADDRESS of EntryPoint;
193 },
194 { // MemoryDxeCore
195 {
196 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
197 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
198 0 // Reserved
199 },
200 {
201 0 // Owner Guid
202 },
203 EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType
204 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
205 // EFI_RESOURCE_ATTRIBUTE_TESTED | // Do not mark as TESTED, or DxeCore will find it and use it before check Allocation
206 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
207 EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
208 EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
209 EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
210 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE),
211 0x0, // PhysicalStart
212 0 // ResourceLength
213 },
214 { // Memory Map Hints to reduce fragmentation in the memory map
215 {
216 {
217 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
218 sizeof (MEMORY_TYPE_INFORMATION_HOB), // Hob size
219 0, // reserved
220 },
221 EFI_MEMORY_TYPE_INFORMATION_GUID
222 },
223 {
224 {
225 EfiACPIReclaimMemory,
226 0x80
227 }, // 0x80 pages = 512k for ASL
228 {
229 EfiACPIMemoryNVS,
230 0x100
231 }, // 0x100 pages = 1024k for S3, SMM, etc
232 {
233 EfiReservedMemoryType,
234 0x04
235 }, // 16k for BIOS Reserved
236 {
237 EfiRuntimeServicesData,
238 0x100
239 },
240 {
241 EfiRuntimeServicesCode,
242 0x100
243 },
244 {
245 EfiBootServicesCode,
246 0x200
247 },
248 {
249 EfiBootServicesData,
250 0x200
251 },
252 {
253 EfiLoaderCode,
254 0x100
255 },
256 {
257 EfiLoaderData,
258 0x100
259 },
260 {
261 EfiMaxMemoryType,
262 0
263 }
264 }
265 },
266 { // Pointer to ACPI Table
267 {
268 {
269 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
270 sizeof (TABLE_HOB), // Hob size
271 0 // reserved
272 },
273 EFI_ACPI_TABLE_GUID
274 },
275 0
276 },
277 { // Pointer to ACPI20 Table
278 {
279 {
280 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
281 sizeof (TABLE_HOB), // Hob size
282 0 // reserved
283 },
284 EFI_ACPI_20_TABLE_GUID
285 },
286 0
287 },
288 { // Pointer to SMBIOS Table
289 {
290 {
291 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
292 sizeof (TABLE_HOB), // Hob size
293 0 // reserved
294 },
295 SMBIOS_TABLE_GUID
296 },
297 0
298 },
299 { // Pointer to MPS Table
300 {
301 {
302 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
303 sizeof (TABLE_HOB), // Hob size
304 0, // reserved
305 },
306 EFI_MPS_TABLE_GUID
307 },
308 0
309 },
310 /**
311 { // Pointer to FlushInstructionCache
312 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
313 sizeof (PROTOCOL_HOB), // Hob size
314 0, // reserved
315 EFI_PEI_FLUSH_INSTRUCTION_CACHE_GUID,
316 NULL
317 },
318 { // Pointer to TransferControl
319 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
320 sizeof (PROTOCOL_HOB), // Hob size
321 0, // reserved
322 EFI_PEI_TRANSFER_CONTROL_GUID,
323 NULL
324 },
325 { // Pointer to PeCoffLoader
326 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
327 sizeof (PROTOCOL_HOB), // Hob size
328 0, // reserved
329 EFI_PEI_PE_COFF_LOADER_GUID,
330 NULL
331 },
332 { // Pointer to EfiDecompress
333 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
334 sizeof (PROTOCOL_HOB), // Hob size
335 0, // reserved
336 EFI_DECOMPRESS_PROTOCOL_GUID,
337 NULL
338 },
339 { // Pointer to TianoDecompress
340 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
341 sizeof (PROTOCOL_HOB), // Hob size
342 0, // reserved
343 EFI_TIANO_DECOMPRESS_PROTOCOL_GUID,
344 NULL
345 },
346 **/
347 { // Pointer to ReportStatusCode
348 {
349 {
350 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
351 sizeof (PROTOCOL_HOB), // Hob size
352 0 // reserved
353 },
354 EFI_STATUS_CODE_RUNTIME_PROTOCOL_GUID
355 },
356 0
357 },
358 { // EFILDR Memory Descriptor
359 {
360 {
361 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
362 sizeof (MEMORY_DESC_HOB), // Hob size
363 0 // reserved
364 },
365 EFI_LDR_MEMORY_DESCRIPTOR_GUID
366 },
367 0,
368 NULL
369 },
370 { // Pci Express Base Address Hob
371 {
372 {
373 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
374 sizeof (PCI_EXPRESS_BASE_HOB), // Hob size
375 0 // reserved
376 },
377 EFI_PCI_EXPRESS_BASE_ADDRESS_GUID
378 },
379 {
380 0,
381 0,
382 0,
383 }
384 },
385 { // Acpi Description Hob
386 {
387 {
388 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
389 sizeof (ACPI_DESCRIPTION_HOB), // Hob size
390 0 // reserved
391 },
392 EFI_ACPI_DESCRIPTION_GUID
393 },
394 {
395 {
396 0,
397 },
398 }
399 },
400 { // NV Storage FV Resource
401 {
402 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
403 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
404 0 // Reserved
405 },
406 {
407 0 // Owner Guid
408 },
409 EFI_RESOURCE_FIRMWARE_DEVICE, // ResourceType
410 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
411 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
412 EFI_RESOURCE_ATTRIBUTE_TESTED |
413 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), // ResourceAttribute
414 0, // PhysicalStart (Fixed later)
415 NV_STORAGE_FVB_SIZE // ResourceLength
416 },
417 { // FVB holding NV Storage
418 {
419 {
420 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
421 sizeof (FVB_HOB),
422 0
423 },
424 EFI_FLASH_MAP_HOB_GUID
425 },
426 {
427 {0, 0, 0}, // Reserved[3]
428 EFI_FLASH_AREA_GUID_DEFINED, // AreaType
429 EFI_SYSTEM_NV_DATA_FV_GUID , // AreaTypeGuid
430 1,
431 {
432 {
433 EFI_FLASH_AREA_FV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes
434 0, // SubAreaData.Reserved
435 0, // SubAreaData.Base (Fixed later)
436 NV_STORAGE_FVB_SIZE, // SubAreaData.Length
437 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem
438 }
439 },
440 0, // VolumeSignature (Fixed later)
441 NV_STORAGE_FILE_PATH, // Mapped file without padding
442 // TotalFVBSize = FileSize + PaddingSize = multiple of BLOCK_SIZE
443 NV_STORAGE_SIZE + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH,
444 // ActuralSize
445 EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH
446 }
447 },
448 { // NV Storage Hob
449 {
450 {
451 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
452 sizeof (FVB_HOB), // Hob size
453 0 // reserved
454 },
455 EFI_FLASH_MAP_HOB_GUID
456 },
457 {
458 {0, 0, 0}, // Reserved[3]
459 EFI_FLASH_AREA_EFI_VARIABLES, // AreaType
460 { 0 }, // AreaTypeGuid
461 1,
462 {
463 {
464 EFI_FLASH_AREA_SUBFV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes
465 0, // SubAreaData.Reserved
466 0, // SubAreaData.Base (Fixed later)
467 NV_STORAGE_SIZE, // SubAreaData.Length
468 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem
469 }
470 },
471 0,
472 NV_STORAGE_FILE_PATH,
473 NV_STORAGE_SIZE,
474 0
475 }
476 },
477 { // NV Ftw FV Resource
478 {
479 EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType
480 sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength
481 0 // Reserved
482 },
483 {
484 0 // Owner Guid
485 },
486 EFI_RESOURCE_FIRMWARE_DEVICE, // ResourceType
487 (EFI_RESOURCE_ATTRIBUTE_PRESENT |
488 EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
489 EFI_RESOURCE_ATTRIBUTE_TESTED |
490 EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), // ResourceAttribute
491 0, // PhysicalStart (Fixed later)
492 NV_FTW_FVB_SIZE // ResourceLength
493 },
494 { // FVB holding FTW spaces including Working & Spare space
495 {
496 {
497 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
498 sizeof (FVB_HOB),
499 0
500 },
501 EFI_FLASH_MAP_HOB_GUID
502 },
503 {
504 {0, 0, 0}, // Reserved[3]
505 EFI_FLASH_AREA_GUID_DEFINED, // AreaType
506 EFI_SYSTEM_NV_DATA_FV_GUID, // AreaTypeGuid
507 1,
508 {
509 {
510 EFI_FLASH_AREA_FV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes
511 0, // SubAreaData.Reserved
512 0, // SubAreaData.Base (Fixed later)
513 NV_FTW_FVB_SIZE, // SubAreaData.Length
514 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem
515 }
516 },
517 0,
518 L"", // Empty String indicates using memory
519 0,
520 0
521 }
522 },
523 { // NV Ftw working Hob
524 {
525 {
526 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
527 sizeof (FVB_HOB), // Hob size
528 0 // reserved
529 },
530 EFI_FLASH_MAP_HOB_GUID
531 },
532 {
533 {0, 0, 0}, // Reserved[3]
534 EFI_FLASH_AREA_FTW_STATE, // AreaType
535 { 0 }, // AreaTypeGuid
536 1,
537 {
538 {
539 EFI_FLASH_AREA_SUBFV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes
540 0, // SubAreaData.Reserved
541 0, // SubAreaData.Base (Fixed later)
542 NV_FTW_WORKING_SIZE, // SubAreaData.Length
543 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem
544 }
545 },
546 0, // VolumeSignature
547 L"",
548 0,
549 0
550 }
551 },
552 { // NV Ftw spare Hob
553 {
554 {
555 EFI_HOB_TYPE_GUID_EXTENSION, // Hob type
556 sizeof (FVB_HOB), // Hob size
557 0 // reserved
558 },
559 EFI_FLASH_MAP_HOB_GUID
560 },
561 {
562 {0, 0, 0}, // Reserved[3]
563 EFI_FLASH_AREA_FTW_BACKUP, // AreaType
564 { 0 }, // AreaTypeGuid
565 1,
566 {
567 {
568 EFI_FLASH_AREA_SUBFV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes
569 0, // SubAreaData.Reserved
570 0, // SubAreaData.Base (Fixed later)
571 NV_FTW_SPARE_SIZE, // SubAreaData.Length
572 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem
573 }
574 },
575 0,
576 L"",
577 0,
578 0
579 }
580 },
581 { // EndOfHobList
582 EFI_HOB_TYPE_END_OF_HOB_LIST, // HobType
583 sizeof (EFI_HOB_GENERIC_HEADER), // HobLength
584 0 // Reserved
585 }
586 };
587
588 HOB_TEMPLATE *gHob = &gHobTemplate;
589
590 VOID *
591 PrepareHobMemory (
592 IN UINTN NumberOfMemoryMapEntries,
593 IN EFI_MEMORY_DESCRIPTOR *EfiMemoryDescriptor
594 )
595 /*++
596 Description:
597 Update the Hob filling MemoryFreeUnder1MB, MemoryAbove1MB, MemoryAbove4GB
598
599 Arguments:
600 NumberOfMemoryMapEntries - Count of Memory Descriptors
601 EfiMemoryDescriptor - Point to the buffer containing NumberOfMemoryMapEntries Memory Descriptors
602
603 Return:
604 VOID * : The end address of MemoryAbove1MB (or the top free memory under 4GB)
605 --*/
606 {
607 UINTN Index;
608
609 //
610 // Prepare Low Memory
611 // 0x18 pages is 72 KB.
612 //
613 gHob->MemoryFreeUnder1MB.ResourceLength = EFI_MEMORY_BELOW_1MB_END - EFI_MEMORY_BELOW_1MB_START;
614 gHob->MemoryFreeUnder1MB.PhysicalStart = EFI_MEMORY_BELOW_1MB_START;
615
616 //
617 // Prepare High Memory
618 // Assume Memory Map is ordered from low to high
619 //
620 gHob->MemoryAbove1MB.PhysicalStart = 0;
621 gHob->MemoryAbove1MB.ResourceLength = 0;
622 gHob->MemoryAbove4GB.PhysicalStart = 0;
623 gHob->MemoryAbove4GB.ResourceLength = 0;
624
625 for (Index = 0; Index < NumberOfMemoryMapEntries; Index++) {
626 //
627 // Skip regions below 1MB
628 //
629 if (EfiMemoryDescriptor[Index].PhysicalStart < 0x100000) {
630 continue;
631 }
632 //
633 // Process regions above 1MB
634 //
635 if (EfiMemoryDescriptor[Index].PhysicalStart >= 0x100000) {
636 if (EfiMemoryDescriptor[Index].Type == EfiConventionalMemory) {
637 if (gHob->MemoryAbove1MB.PhysicalStart == 0) {
638 gHob->MemoryAbove1MB.PhysicalStart = EfiMemoryDescriptor[Index].PhysicalStart;
639 gHob->MemoryAbove1MB.ResourceLength = LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT);
640 } else if (gHob->MemoryAbove1MB.PhysicalStart + gHob->MemoryAbove1MB.ResourceLength == EfiMemoryDescriptor[Index].PhysicalStart) {
641 gHob->MemoryAbove1MB.ResourceLength += LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT);
642 }
643 }
644 if ((EfiMemoryDescriptor[Index].Type == EfiReservedMemoryType) ||
645 (EfiMemoryDescriptor[Index].Type >= EfiACPIReclaimMemory) ) {
646 continue;
647 }
648 if ((EfiMemoryDescriptor[Index].Type == EfiRuntimeServicesCode) ||
649 (EfiMemoryDescriptor[Index].Type == EfiRuntimeServicesData)) {
650 break;
651 }
652 }
653 //
654 // Process region above 4GB
655 //
656 if (EfiMemoryDescriptor[Index].PhysicalStart >= 0x100000000LL) {
657 if (EfiMemoryDescriptor[Index].Type == EfiConventionalMemory) {
658 if (gHob->MemoryAbove4GB.PhysicalStart == 0) {
659 gHob->MemoryAbove4GB.PhysicalStart = EfiMemoryDescriptor[Index].PhysicalStart;
660 gHob->MemoryAbove4GB.ResourceLength = LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT);
661 }
662 if (gHob->MemoryAbove4GB.PhysicalStart + gHob->MemoryAbove4GB.ResourceLength ==
663 EfiMemoryDescriptor[Index].PhysicalStart) {
664 gHob->MemoryAbove4GB.ResourceLength += LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT);
665 }
666 }
667 }
668 }
669
670 if (gHob->MemoryAbove4GB.ResourceLength == 0) {
671 //
672 // If there is no memory above 4GB then change the resource descriptor HOB
673 // into another type. I'm doing this as it's unclear if a resource
674 // descriptor HOB of length zero is valid. Spec does not say it's illegal,
675 // but code in EDK does not seem to handle this case.
676 //
677 gHob->MemoryAbove4GB.Header.HobType = EFI_HOB_TYPE_UNUSED;
678 }
679
680 return (VOID *)(UINTN)(gHob->MemoryAbove1MB.PhysicalStart + gHob->MemoryAbove1MB.ResourceLength);
681 }
682
683 VOID *
684 PrepareHobStack (
685 IN VOID *StackTop
686 )
687 {
688 gHob->Stack.AllocDescriptor.MemoryLength = EFI_MEMORY_STACK_PAGE_NUM * EFI_PAGE_SIZE;
689 gHob->Stack.AllocDescriptor.MemoryBaseAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)StackTop - gHob->Stack.AllocDescriptor.MemoryLength;
690
691 return (VOID *)(UINTN)gHob->Stack.AllocDescriptor.MemoryBaseAddress;
692 }
693
694 VOID *
695 PrepareHobMemoryDescriptor (
696 VOID *MemoryDescriptorTop,
697 UINTN MemDescCount,
698 EFI_MEMORY_DESCRIPTOR *MemDesc
699 )
700 {
701 gHob->MemoryDescriptor.MemDescCount = MemDescCount;
702 gHob->MemoryDescriptor.MemDesc = (EFI_MEMORY_DESCRIPTOR *)((UINTN)MemoryDescriptorTop - MemDescCount * sizeof(EFI_MEMORY_DESCRIPTOR));
703 //
704 // Make MemoryDescriptor.MemDesc page aligned
705 //
706 gHob->MemoryDescriptor.MemDesc = (EFI_MEMORY_DESCRIPTOR *)((UINTN) gHob->MemoryDescriptor.MemDesc & ~EFI_PAGE_MASK);
707
708 CopyMem (gHob->MemoryDescriptor.MemDesc, MemDesc, MemDescCount * sizeof(EFI_MEMORY_DESCRIPTOR));
709
710 return gHob->MemoryDescriptor.MemDesc;
711 }
712
713 VOID
714 PrepareHobBfv (
715 VOID *Bfv,
716 UINTN BfvLength
717 )
718 {
719 //UINTN BfvLengthPageSize;
720
721 //
722 // Calculate BFV location at top of the memory region.
723 // This is like a RAM Disk. Align to page boundry.
724 //
725 //BfvLengthPageSize = EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (BfvLength));
726
727 gHob->Bfv.BaseAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Bfv;
728 gHob->Bfv.Length = BfvLength;
729
730 //
731 // Resource descriptor for the FV
732 //
733 gHob->BfvResource.PhysicalStart = gHob->Bfv.BaseAddress;
734 gHob->BfvResource.ResourceLength = gHob->Bfv.Length;
735 }
736
737 VOID
738 PrepareHobDxeCore (
739 VOID *DxeCoreEntryPoint,
740 EFI_PHYSICAL_ADDRESS DxeCoreImageBase,
741 UINT64 DxeCoreLength
742 )
743 {
744 gHob->DxeCore.MemoryAllocationHeader.MemoryBaseAddress = DxeCoreImageBase;
745 gHob->DxeCore.MemoryAllocationHeader.MemoryLength = DxeCoreLength;
746 gHob->DxeCore.EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)DxeCoreEntryPoint;
747
748
749 gHob->MemoryDxeCore.PhysicalStart = DxeCoreImageBase;
750 gHob->MemoryDxeCore.ResourceLength = DxeCoreLength;
751 }
752
753 VOID *
754 PrepareHobNvStorage (
755 VOID *NvStorageTop
756 )
757 /*
758 Initialize Block-Aligned Firmware Block.
759
760 Variable:
761 +-------------------+
762 | FV_Header |
763 +-------------------+
764 | |
765 |VAR_STORAGE(0x4000)|
766 | |
767 +-------------------+
768 FTW:
769 +-------------------+
770 | FV_Header |
771 +-------------------+
772 | |
773 | Working(0x2000) |
774 | |
775 +-------------------+
776 | |
777 | Spare(0x10000) |
778 | |
779 +-------------------+
780 */
781 {
782 STATIC VARIABLE_STORE_HEADER VarStoreHeader = {
783 VARIABLE_STORE_SIGNATURE,
784 0xffffffff, // will be fixed in Variable driver
785 VARIABLE_STORE_FORMATTED,
786 VARIABLE_STORE_HEALTHY,
787 0,
788 0
789 };
790
791 STATIC EFI_FIRMWARE_VOLUME_HEADER NvStorageFvbHeader = {
792 {
793 0,
794 }, // ZeroVector[16]
795 EFI_SYSTEM_NV_DATA_FV_GUID,
796 NV_STORAGE_FVB_SIZE,
797 EFI_FVH_SIGNATURE,
798 EFI_FVB_READ_ENABLED_CAP |
799 EFI_FVB_READ_STATUS |
800 EFI_FVB_WRITE_ENABLED_CAP |
801 EFI_FVB_WRITE_STATUS |
802 EFI_FVB_ERASE_POLARITY,
803 EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH,
804 0, // CheckSum
805 0, // ExtHeaderOffset
806 {
807 0,
808 }, // Reserved[1]
809 1, // Revision
810 {
811 {
812 NV_STORAGE_FVB_BLOCK_NUM,
813 FV_BLOCK_SIZE,
814 }
815 }
816 };
817
818 STATIC EFI_FV_BLOCK_MAP_ENTRY BlockMapEntryEnd = {0, 0};
819
820 EFI_PHYSICAL_ADDRESS StorageFvbBase;
821 EFI_PHYSICAL_ADDRESS FtwFvbBase;
822
823 UINT16 *Ptr;
824 UINT16 Checksum;
825
826
827 //
828 // Use first 16-byte Reset Vector of FVB to store extra information
829 // UINT32 Offset 0 stores the volume signature
830 // UINT8 Offset 4 : should init the Variable Store Header if non-zero
831 //
832 gHob->NvStorageFvb.FvbInfo.VolumeId = *(UINT32 *) (UINTN) (NV_STORAGE_STATE);
833 gHob->NvStorage. FvbInfo.VolumeId = *(UINT32 *) (UINTN) (NV_STORAGE_STATE);
834
835 //
836 // *(NV_STORAGE_STATE + 4):
837 // 2 - Size error
838 // 1 - File not exist
839 // 0 - File exist with correct size
840 //
841 if (*(UINT8 *) (UINTN) (NV_STORAGE_STATE + 4) == 2) {
842 ClearScreen ();
843 PrintString ("Error: Size of Efivar.bin should be 16k!\n");
844 CpuDeadLoop();
845 }
846
847 if (*(UINT8 *) (UINTN) (NV_STORAGE_STATE + 4) != 0) {
848 //
849 // Efivar.bin doesn't exist
850 // 1. Init variable storage header to valid header
851 //
852 CopyMem (
853 (VOID *) (UINTN) NV_STORAGE_START,
854 &VarStoreHeader,
855 sizeof (VARIABLE_STORE_HEADER)
856 );
857 //
858 // 2. set all bits in variable storage body to 1
859 //
860 SetMem (
861 (VOID *) (UINTN) (NV_STORAGE_START + sizeof (VARIABLE_STORE_HEADER)),
862 NV_STORAGE_SIZE - sizeof (VARIABLE_STORE_HEADER),
863 0xff
864 );
865 }
866
867 //
868 // Relocate variable storage
869 //
870 // 1. Init FVB Header to valid header: First 0x48 bytes
871 // In real platform, these fields are fixed by tools
872 //
873 //
874 Checksum = 0;
875 for (
876 Ptr = (UINT16 *) &NvStorageFvbHeader;
877 Ptr < (UINT16 *) ((UINTN) (UINT8 *) &NvStorageFvbHeader + sizeof (EFI_FIRMWARE_VOLUME_HEADER));
878 ++Ptr
879 ) {
880 Checksum = (UINT16) (Checksum + (*Ptr));
881 }
882 NvStorageFvbHeader.Checksum = (UINT16) (0x10000 - Checksum);
883 StorageFvbBase = (EFI_PHYSICAL_ADDRESS)(((UINTN)NvStorageTop - NV_STORAGE_FVB_SIZE - NV_FTW_FVB_SIZE) & ~EFI_PAGE_MASK);
884 CopyMem ((VOID *) (UINTN) StorageFvbBase, &NvStorageFvbHeader, sizeof (EFI_FIRMWARE_VOLUME_HEADER));
885 CopyMem (
886 (VOID *) (UINTN) (StorageFvbBase + sizeof (EFI_FIRMWARE_VOLUME_HEADER)),
887 &BlockMapEntryEnd,
888 sizeof (EFI_FV_BLOCK_MAP_ENTRY)
889 );
890
891 //
892 // 2. Relocate variable data
893 //
894 CopyMem (
895 (VOID *) (UINTN) (StorageFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH),
896 (VOID *) (UINTN) NV_STORAGE_START,
897 NV_STORAGE_SIZE
898 );
899
900 //
901 // 3. Set the remaining memory to 0xff
902 //
903 SetMem (
904 (VOID *) (UINTN) (StorageFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH + NV_STORAGE_SIZE),
905 NV_STORAGE_FVB_SIZE - NV_STORAGE_SIZE - EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH,
906 0xff
907 );
908
909 //
910 // Create the FVB holding NV Storage in memory
911 //
912 gHob->NvStorageFvResource.PhysicalStart =
913 gHob->NvStorageFvb.FvbInfo.Entries[0].Base = StorageFvbBase;
914 //
915 // Create the NV Storage Hob
916 //
917 gHob->NvStorage.FvbInfo.Entries[0].Base = StorageFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH;
918
919 //
920 // Create the FVB holding FTW spaces
921 //
922 FtwFvbBase = (EFI_PHYSICAL_ADDRESS)((UINTN) StorageFvbBase + NV_STORAGE_FVB_SIZE);
923 gHob->NvFtwFvResource.PhysicalStart =
924 gHob->NvFtwFvb.FvbInfo.Entries[0].Base = FtwFvbBase;
925 //
926 // Put FTW Working in front
927 //
928 gHob->NvFtwWorking.FvbInfo.Entries[0].Base = FtwFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH;
929
930 //
931 // Put FTW Spare area after FTW Working area
932 //
933 gHob->NvFtwSpare.FvbInfo.Entries[0].Base =
934 (EFI_PHYSICAL_ADDRESS)((UINTN) FtwFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH + NV_FTW_WORKING_SIZE);
935
936 return (VOID *)(UINTN)StorageFvbBase;
937 }
938
939 VOID
940 PrepareHobPhit (
941 VOID *MemoryTop,
942 VOID *FreeMemoryTop
943 )
944 {
945 gHob->Phit.EfiMemoryTop = (EFI_PHYSICAL_ADDRESS)(UINTN)MemoryTop;
946 gHob->Phit.EfiMemoryBottom = gHob->Phit.EfiMemoryTop - CONSUMED_MEMORY;
947 gHob->Phit.EfiFreeMemoryTop = (EFI_PHYSICAL_ADDRESS)(UINTN)FreeMemoryTop;
948 gHob->Phit.EfiFreeMemoryBottom = gHob->Phit.EfiMemoryBottom + sizeof(HOB_TEMPLATE);
949
950 CopyMem ((VOID *)(UINTN)gHob->Phit.EfiMemoryBottom, gHob, sizeof(HOB_TEMPLATE));
951 gHob = (HOB_TEMPLATE *)(UINTN)gHob->Phit.EfiMemoryBottom;
952
953 gHob->Phit.EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS)(UINTN)&gHob->EndOfHobList;
954 }
955
956 VOID
957 PrepareHobCpu (
958 VOID
959 )
960 {
961 UINT32 CpuidEax;
962
963 //
964 // Create a CPU hand-off information
965 //
966 gHob->Cpu.SizeOfMemorySpace = 36;
967
968 AsmCpuid (EFI_CPUID_EXTENDED_FUNCTION, &CpuidEax, NULL, NULL, NULL);
969 if (CpuidEax >= CPUID_EXTENDED_ADD_SIZE) {
970 AsmCpuid (CPUID_EXTENDED_ADD_SIZE, &CpuidEax, NULL, NULL, NULL);
971 gHob->Cpu.SizeOfMemorySpace = (UINT8)(CpuidEax & 0xFF);
972 }
973 }
974
975 VOID
976 CompleteHobGeneration (
977 VOID
978 )
979 {
980 gHob->MemoryAllocation.AllocDescriptor.MemoryBaseAddress = gHob->Phit.EfiFreeMemoryTop;
981 //
982 // Reserve all the memory under Stack above FreeMemoryTop as allocated
983 //
984 gHob->MemoryAllocation.AllocDescriptor.MemoryLength = gHob->Stack.AllocDescriptor.MemoryBaseAddress - gHob->Phit.EfiFreeMemoryTop;
985
986 //
987 // adjust Above1MB ResourceLength
988 //
989 if (gHob->MemoryAbove1MB.PhysicalStart + gHob->MemoryAbove1MB.ResourceLength > gHob->Phit.EfiMemoryTop) {
990 gHob->MemoryAbove1MB.ResourceLength = gHob->Phit.EfiMemoryTop - gHob->MemoryAbove1MB.PhysicalStart;
991 }
992 }
993
EFI Development Kit II mirror for PVE