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