2 Pei Core Firmware File System service routines.
4 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
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.
17 EFI_PEI_NOTIFY_DESCRIPTOR mNotifyOnFvInfoList
= {
18 (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
19 &gEfiPeiFirmwareVolumeInfoPpiGuid
,
20 FirmwareVolmeInfoPpiNotifyCallback
23 EFI_PEI_FIRMWARE_VOLUME_PPI mPeiFfs2FvPpi
= {
24 PeiFfs2FvPpiProcessVolume
,
25 PeiFfs2FvPpiFindFileByType
,
26 PeiFfs2FvPpiFindFileByName
,
27 PeiFfs2FvPpiGetFileInfo
,
28 PeiFfs2FvPpiGetVolumeInfo
,
29 PeiFfs2FvPpiFindSectionByType
32 EFI_PEI_PPI_DESCRIPTOR mPeiFfs2FvPpiList
= {
33 (EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
34 &gEfiFirmwareFileSystem2Guid
,
39 Returns the file state set by the highest zero bit in the State field
41 @param ErasePolarity Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY
42 in the Attributes field.
43 @param FfsHeader Pointer to FFS File Header.
45 @retval EFI_FFS_FILE_STATE File state is set by the highest none zero bit
46 in the header State field.
50 IN UINT8 ErasePolarity
,
51 IN EFI_FFS_FILE_HEADER
*FfsHeader
54 EFI_FFS_FILE_STATE FileState
;
55 EFI_FFS_FILE_STATE HighestBit
;
57 FileState
= FfsHeader
->State
;
59 if (ErasePolarity
!= 0) {
60 FileState
= (EFI_FFS_FILE_STATE
)~FileState
;
64 // Get file state set by its highest none zero bit.
67 while (HighestBit
!= 0 && (HighestBit
& FileState
) == 0) {
75 Calculates the checksum of the header of a file.
77 @param FileHeader Pointer to FFS File Header.
79 @return Checksum of the header.
80 Zero means the header is good.
81 Non-zero means the header is bad.
84 CalculateHeaderChecksum (
85 IN EFI_FFS_FILE_HEADER
*FileHeader
88 EFI_FFS_FILE_HEADER TestFileHeader
;
90 CopyMem (&TestFileHeader
, FileHeader
, sizeof (EFI_FFS_FILE_HEADER
));
92 // Ingore State and File field in FFS header.
94 TestFileHeader
.State
= 0;
95 TestFileHeader
.IntegrityCheck
.Checksum
.File
= 0;
97 return CalculateSum8 ((CONST UINT8
*) &TestFileHeader
, sizeof (EFI_FFS_FILE_HEADER
));
101 Find FV handler according to FileHandle in that FV.
103 @param FileHandle Handle of file image
105 @return Pointer to instance of PEI_CORE_FV_HANDLE.
109 IN EFI_PEI_FILE_HANDLE FileHandle
113 PEI_CORE_INSTANCE
*PrivateData
;
114 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
116 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
118 for (Index
= 0; Index
< PrivateData
->FvCount
; Index
++) {
119 FwVolHeader
= PrivateData
->Fv
[Index
].FvHeader
;
120 if (((UINT64
) (UINTN
) FileHandle
> (UINT64
) (UINTN
) FwVolHeader
) && \
121 ((UINT64
) (UINTN
) FileHandle
<= ((UINT64
) (UINTN
) FwVolHeader
+ FwVolHeader
->FvLength
- 1))) {
122 return &PrivateData
->Fv
[Index
];
129 Given the input file pointer, search for the first matching file in the
130 FFS volume as defined by SearchType. The search starts from FileHeader inside
131 the Firmware Volume defined by FwVolHeader.
132 If SearchType is EFI_FV_FILETYPE_ALL, the first FFS file will return without check its file type.
133 If SearchType is PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE,
134 the first PEIM, or COMBINED PEIM or FV file type FFS file will return.
136 @param FvHandle Pointer to the FV header of the volume to search
137 @param FileName File name
138 @param SearchType Filter to find only files of this type.
139 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
140 @param FileHandle This parameter must point to a valid FFS volume.
141 @param AprioriFile Pointer to AprioriFile image in this FV if has
143 @return EFI_NOT_FOUND No files matching the search criteria were found
144 @retval EFI_SUCCESS Success to search given file
149 IN CONST EFI_PEI_FV_HANDLE FvHandle
,
150 IN CONST EFI_GUID
*FileName
, OPTIONAL
151 IN EFI_FV_FILETYPE SearchType
,
152 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
,
153 IN OUT EFI_PEI_FV_HANDLE
*AprioriFile OPTIONAL
156 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
157 EFI_FFS_FILE_HEADER
**FileHeader
;
158 EFI_FFS_FILE_HEADER
*FfsFileHeader
;
160 UINT32 FileOccupiedSize
;
168 // Convert the handle of FV to FV header for memory-mapped firmware volume
170 FwVolHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) FvHandle
;
171 FileHeader
= (EFI_FFS_FILE_HEADER
**)FileHandle
;
173 FvLength
= FwVolHeader
->FvLength
;
174 if ((FwVolHeader
->Attributes
& EFI_FVB2_ERASE_POLARITY
) != 0) {
181 // If FileHeader is not specified (NULL) or FileName is not NULL,
182 // start with the first file in the firmware volume. Otherwise,
183 // start from the FileHeader.
185 if ((*FileHeader
== NULL
) || (FileName
!= NULL
)) {
186 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FwVolHeader
+ FwVolHeader
->HeaderLength
);
189 // Length is 24 bits wide so mask upper 8 bits
190 // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
192 FileLength
= *(UINT32
*)(*FileHeader
)->Size
& 0x00FFFFFF;
193 FileOccupiedSize
= GET_OCCUPIED_SIZE (FileLength
, 8);
194 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)*FileHeader
+ FileOccupiedSize
);
197 FileOffset
= (UINT32
) ((UINT8
*)FfsFileHeader
- (UINT8
*)FwVolHeader
);
198 ASSERT (FileOffset
<= 0xFFFFFFFF);
200 while (FileOffset
< (FvLength
- sizeof (EFI_FFS_FILE_HEADER
))) {
202 // Get FileState which is the highest bit of the State
204 FileState
= GetFileState (ErasePolarity
, FfsFileHeader
);
207 case EFI_FILE_HEADER_INVALID
:
208 FileOffset
+= sizeof(EFI_FFS_FILE_HEADER
);
209 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ sizeof(EFI_FFS_FILE_HEADER
));
212 case EFI_FILE_DATA_VALID
:
213 case EFI_FILE_MARKED_FOR_UPDATE
:
214 if (CalculateHeaderChecksum (FfsFileHeader
) != 0) {
217 return EFI_NOT_FOUND
;
220 FileLength
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
221 FileOccupiedSize
= GET_OCCUPIED_SIZE(FileLength
, 8);
223 DataCheckSum
= FFS_FIXED_CHECKSUM
;
224 if ((FfsFileHeader
->Attributes
& FFS_ATTRIB_CHECKSUM
) == FFS_ATTRIB_CHECKSUM
) {
225 DataCheckSum
= CalculateCheckSum8 ((CONST UINT8
*)FfsFileHeader
+ sizeof(EFI_FFS_FILE_HEADER
), FileLength
- sizeof(EFI_FFS_FILE_HEADER
));
227 if (FfsFileHeader
->IntegrityCheck
.Checksum
.File
!= DataCheckSum
) {
230 return EFI_NOT_FOUND
;
233 if (FileName
!= NULL
) {
234 if (CompareGuid (&FfsFileHeader
->Name
, (EFI_GUID
*)FileName
)) {
235 *FileHeader
= FfsFileHeader
;
238 } else if (SearchType
== PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE
) {
239 if ((FfsFileHeader
->Type
== EFI_FV_FILETYPE_PEIM
) ||
240 (FfsFileHeader
->Type
== EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER
) ||
241 (FfsFileHeader
->Type
== EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
)) {
243 *FileHeader
= FfsFileHeader
;
245 } else if (AprioriFile
!= NULL
) {
246 if (FfsFileHeader
->Type
== EFI_FV_FILETYPE_FREEFORM
) {
247 if (CompareGuid (&FfsFileHeader
->Name
, &gPeiAprioriFileNameGuid
)) {
248 *AprioriFile
= FfsFileHeader
;
252 } else if (((SearchType
== FfsFileHeader
->Type
) || (SearchType
== EFI_FV_FILETYPE_ALL
)) &&
253 (FfsFileHeader
->Type
!= EFI_FV_FILETYPE_FFS_PAD
)) {
254 *FileHeader
= FfsFileHeader
;
258 FileOffset
+= FileOccupiedSize
;
259 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ FileOccupiedSize
);
262 case EFI_FILE_DELETED
:
263 FileLength
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
264 FileOccupiedSize
= GET_OCCUPIED_SIZE(FileLength
, 8);
265 FileOffset
+= FileOccupiedSize
;
266 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ FileOccupiedSize
);
271 return EFI_NOT_FOUND
;
276 return EFI_NOT_FOUND
;
280 Initialize PeiCore Fv List.
282 @param PrivateData - Pointer to PEI_CORE_INSTANCE.
283 @param SecCoreData - Pointer to EFI_SEC_PEI_HAND_OFF.
287 IN PEI_CORE_INSTANCE
*PrivateData
,
288 IN CONST EFI_SEC_PEI_HAND_OFF
*SecCoreData
292 EFI_PEI_FIRMWARE_VOLUME_PPI
*FvPpi
;
293 EFI_PEI_FV_HANDLE FvHandle
;
294 EFI_FIRMWARE_VOLUME_HEADER
*BfvHeader
;
297 // Install FV_PPI for FFS2 file system.
299 PeiServicesInstallPpi (&mPeiFfs2FvPpiList
);
301 BfvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)SecCoreData
->BootFirmwareVolumeBase
;
304 // The FV_PPI in BFV's format should be installed.
306 Status
= PeiServicesLocatePpi (
307 &BfvHeader
->FileSystemGuid
,
312 ASSERT_EFI_ERROR (Status
);
317 FvPpi
->ProcessVolume (
319 SecCoreData
->BootFirmwareVolumeBase
,
320 (UINTN
)BfvHeader
->FvLength
,
325 // Update internal PEI_CORE_FV array.
327 PrivateData
->Fv
[PrivateData
->FvCount
].FvHeader
= BfvHeader
;
328 PrivateData
->Fv
[PrivateData
->FvCount
].FvPpi
= FvPpi
;
329 PrivateData
->Fv
[PrivateData
->FvCount
].FvHandle
= FvHandle
;
332 "The %dth FV start address is 0x%11p, size is 0x%08x, handle is 0x%p\n",
333 (UINT32
) PrivateData
->FvCount
,
338 PrivateData
->FvCount
++;
341 // Post a call-back for the FvInfoPPI services to expose
342 // additional Fvs to PeiCore.
344 Status
= PeiServicesNotifyPpi (&mNotifyOnFvInfoList
);
345 ASSERT_EFI_ERROR (Status
);
350 Process Firmware Volum Information once FvInfoPPI install.
351 The FV Info will be registered into PeiCore private data structure.
352 And search the inside FV image, if found, the new FV INFO PPI will be installed.
354 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
355 @param NotifyDescriptor Address of the notification descriptor data structure.
356 @param Ppi Address of the PPI that was installed.
358 @retval EFI_SUCCESS The FV Info is registered into PeiCore private data structure.
359 @return if not EFI_SUCESS, fail to verify FV.
364 FirmwareVolmeInfoPpiNotifyCallback (
365 IN EFI_PEI_SERVICES
**PeiServices
,
366 IN EFI_PEI_NOTIFY_DESCRIPTOR
*NotifyDescriptor
,
370 EFI_PEI_FIRMWARE_VOLUME_INFO_PPI
*FvInfoPpi
;
371 EFI_PEI_FIRMWARE_VOLUME_PPI
*FvPpi
;
372 PEI_CORE_INSTANCE
*PrivateData
;
374 EFI_PEI_FV_HANDLE FvHandle
;
376 EFI_PEI_FILE_HANDLE FileHandle
;
379 Status
= EFI_SUCCESS
;
380 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
382 if (PrivateData
->FvCount
>= FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)) {
383 DEBUG ((EFI_D_ERROR
, "The number of Fv Images (%d) exceed the max supported FVs (%d) in Pei", PrivateData
->FvCount
+ 1, FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)));
384 DEBUG ((EFI_D_ERROR
, "PcdPeiCoreMaxFvSupported value need be reconfigurated in DSC"));
388 FvInfoPpi
= (EFI_PEI_FIRMWARE_VOLUME_INFO_PPI
*)Ppi
;
391 // Locate the corresponding FV_PPI according to founded FV's format guid
393 Status
= PeiServicesLocatePpi (
394 &FvInfoPpi
->FvFormat
,
399 if (!EFI_ERROR (Status
)) {
401 // Process new found FV and get FV handle.
403 Status
= FvPpi
->ProcessVolume (FvPpi
, FvInfoPpi
->FvInfo
, FvInfoPpi
->FvInfoSize
, &FvHandle
);
404 if (EFI_ERROR (Status
)) {
405 DEBUG ((EFI_D_ERROR
, "Fail to process new found FV, FV may be corrupted!\n"));
410 // Check whether the FV has already been processed.
412 for (FvIndex
= 0; FvIndex
< PrivateData
->FvCount
; FvIndex
++) {
413 if (PrivateData
->Fv
[FvIndex
].FvHandle
== FvHandle
) {
414 DEBUG ((EFI_D_INFO
, "The Fv %p has already been processed!\n", FvInfoPpi
->FvInfo
));
420 // Update internal PEI_CORE_FV array.
422 PrivateData
->Fv
[PrivateData
->FvCount
].FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) FvInfoPpi
->FvInfo
;
423 PrivateData
->Fv
[PrivateData
->FvCount
].FvPpi
= FvPpi
;
424 PrivateData
->Fv
[PrivateData
->FvCount
].FvHandle
= FvHandle
;
427 "The %dth FV start address is 0x%11p, size is 0x%08x, handle is 0x%p\n",
428 (UINT32
) PrivateData
->FvCount
,
429 (VOID
*) FvInfoPpi
->FvInfo
,
430 FvInfoPpi
->FvInfoSize
,
433 PrivateData
->FvCount
++;
436 // Scan and process the new discoveried FV for EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
440 Status
= FvPpi
->FindFileByType (
442 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
,
446 if (!EFI_ERROR (Status
)) {
447 Status
= FvPpi
->FindSectionByType (
449 EFI_SECTION_PEI_DEPEX
,
453 if (!EFI_ERROR (Status
)) {
454 if (!PeimDispatchReadiness (PeiServices
, DepexData
)) {
456 // Dependency is not satisfied.
462 DEBUG ((EFI_D_INFO
, "Found firmware volume Image File %p in FV[%d] %p\n", FileHandle
, PrivateData
->FvCount
- 1, FvHandle
));
463 ProcessFvFile (&PrivateData
->Fv
[PrivateData
->FvCount
- 1], FileHandle
);
465 } while (FileHandle
!= NULL
);
467 DEBUG ((EFI_D_ERROR
, "Fail to process FV %p because no corresponding EFI_FIRMWARE_VOLUME_PPI is found!\n", FvInfoPpi
->FvInfo
));
469 AddUnknownFormatFvInfo (PrivateData
, &FvInfoPpi
->FvFormat
, FvInfoPpi
->FvInfo
, FvInfoPpi
->FvInfoSize
);
476 Go through the file to search SectionType section.
477 Search within encapsulation sections (compression and GUIDed) recursively,
478 until the match section is found.
480 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
481 @param SectionType Filter to find only section of this type.
482 @param Section From where to search.
483 @param SectionSize The file size to search.
484 @param OutputBuffer A pointer to the discovered section, if successful.
485 NULL if section not found
487 @return EFI_NOT_FOUND The match section is not found.
488 @return EFI_SUCCESS The match section is found.
493 IN CONST EFI_PEI_SERVICES
**PeiServices
,
494 IN EFI_SECTION_TYPE SectionType
,
495 IN EFI_COMMON_SECTION_HEADER
*Section
,
496 IN UINTN SectionSize
,
497 OUT VOID
**OutputBuffer
501 UINT32 SectionLength
;
503 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
*GuidSectionPpi
;
504 EFI_PEI_DECOMPRESS_PPI
*DecompressPpi
;
508 UINT32 Authentication
;
509 PEI_CORE_INSTANCE
*PrivateData
;
511 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
512 *OutputBuffer
= NULL
;
515 Status
= EFI_NOT_FOUND
;
518 while (ParsedLength
< SectionSize
) {
519 if (Section
->Type
== SectionType
) {
520 *OutputBuffer
= (VOID
*)(Section
+ 1);
522 } else if ((Section
->Type
== EFI_SECTION_GUID_DEFINED
) || (Section
->Type
== EFI_SECTION_COMPRESSION
)) {
524 // Check the encapsulated section is extracted into the cache data.
526 for (Index
= 0; Index
< PrivateData
->CacheSection
.AllSectionCount
; Index
++) {
527 if (Section
== PrivateData
->CacheSection
.Section
[Index
]) {
528 PpiOutput
= PrivateData
->CacheSection
.SectionData
[Index
];
529 PpiOutputSize
= PrivateData
->CacheSection
.SectionSize
[Index
];
531 // Search section directly from the cache data.
533 return ProcessSection (
543 Status
= EFI_NOT_FOUND
;
544 if (Section
->Type
== EFI_SECTION_GUID_DEFINED
) {
545 Status
= PeiServicesLocatePpi (
546 &((EFI_GUID_DEFINED_SECTION
*)Section
)->SectionDefinitionGuid
,
549 (VOID
**) &GuidSectionPpi
551 if (!EFI_ERROR (Status
)) {
552 Status
= GuidSectionPpi
->ExtractSection (
560 } else if (Section
->Type
== EFI_SECTION_COMPRESSION
) {
561 Status
= PeiServicesLocatePpi (&gEfiPeiDecompressPpiGuid
, 0, NULL
, (VOID
**) &DecompressPpi
);
562 if (!EFI_ERROR (Status
)) {
563 Status
= DecompressPpi
->Decompress (
565 (CONST EFI_COMPRESSION_SECTION
*) Section
,
572 if (!EFI_ERROR (Status
)) {
574 // Update cache section data.
576 if (PrivateData
->CacheSection
.AllSectionCount
< CACHE_SETION_MAX_NUMBER
) {
577 PrivateData
->CacheSection
.AllSectionCount
++;
579 PrivateData
->CacheSection
.Section
[PrivateData
->CacheSection
.SectionIndex
] = Section
;
580 PrivateData
->CacheSection
.SectionData
[PrivateData
->CacheSection
.SectionIndex
] = PpiOutput
;
581 PrivateData
->CacheSection
.SectionSize
[PrivateData
->CacheSection
.SectionIndex
] = PpiOutputSize
;
582 PrivateData
->CacheSection
.SectionIndex
= (PrivateData
->CacheSection
.SectionIndex
+ 1)%CACHE_SETION_MAX_NUMBER
;
584 return ProcessSection (
595 // Size is 24 bits wide so mask upper 8 bits.
596 // SectionLength is adjusted it is 4 byte aligned.
597 // Go to the next section
599 SectionLength
= *(UINT32
*)Section
->Size
& 0x00FFFFFF;
600 SectionLength
= GET_OCCUPIED_SIZE (SectionLength
, 4);
601 ASSERT (SectionLength
!= 0);
602 ParsedLength
+= SectionLength
;
603 Section
= (EFI_COMMON_SECTION_HEADER
*)((UINT8
*)Section
+ SectionLength
);
606 return EFI_NOT_FOUND
;
611 Searches for the next matching section within the specified file.
613 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
614 @param SectionType Filter to find only sections of this type.
615 @param FileHandle Pointer to the current file to search.
616 @param SectionData A pointer to the discovered section, if successful.
617 NULL if section not found
619 @retval EFI_NOT_FOUND The section was not found.
620 @retval EFI_SUCCESS The section was found.
625 PeiFfsFindSectionData (
626 IN CONST EFI_PEI_SERVICES
**PeiServices
,
627 IN EFI_SECTION_TYPE SectionType
,
628 IN EFI_PEI_FILE_HANDLE FileHandle
,
629 OUT VOID
**SectionData
632 PEI_CORE_FV_HANDLE
*CoreFvHandle
;
634 CoreFvHandle
= FileHandleToVolume (FileHandle
);
635 if ((CoreFvHandle
== NULL
) || (CoreFvHandle
->FvPpi
== NULL
)) {
636 return EFI_NOT_FOUND
;
639 return CoreFvHandle
->FvPpi
->FindSectionByType (CoreFvHandle
->FvPpi
, SectionType
, FileHandle
, SectionData
);
643 Searches for the next matching file in the firmware volume.
645 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
646 @param SearchType Filter to find only files of this type.
647 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
648 @param FvHandle Handle of firmware volume in which to search.
649 @param FileHandle On entry, points to the current handle from which to begin searching or NULL to start
650 at the beginning of the firmware volume. On exit, points the file handle of the next file
651 in the volume or NULL if there are no more files.
653 @retval EFI_NOT_FOUND The file was not found.
654 @retval EFI_NOT_FOUND The header checksum was not zero.
655 @retval EFI_SUCCESS The file was found.
661 IN CONST EFI_PEI_SERVICES
**PeiServices
,
663 IN EFI_PEI_FV_HANDLE FvHandle
,
664 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
667 PEI_CORE_FV_HANDLE
*CoreFvHandle
;
669 CoreFvHandle
= FvHandleToCoreHandle (FvHandle
);
672 // To make backward compatiblity, if can not find corresponding the handle of FV
673 // then treat FV as build-in FFS2 format and memory mapped FV that FV handle is pointed
674 // to the address of first byte of FV.
676 if ((CoreFvHandle
== NULL
) && FeaturePcdGet (PcdFrameworkCompatibilitySupport
)) {
677 return FindFileEx (FvHandle
, NULL
, SearchType
, FileHandle
, NULL
);
680 if ((CoreFvHandle
== NULL
) || CoreFvHandle
->FvPpi
== NULL
) {
681 return EFI_NOT_FOUND
;
684 return CoreFvHandle
->FvPpi
->FindFileByType (CoreFvHandle
->FvPpi
, SearchType
, FvHandle
, FileHandle
);
689 Search the firmware volumes by index
691 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
692 @param Instance This instance of the firmware volume to find. The value 0 is the Boot Firmware
694 @param VolumeHandle On exit, points to the next volume handle or NULL if it does not exist.
696 @retval EFI_INVALID_PARAMETER VolumeHandle is NULL
697 @retval EFI_NOT_FOUND The volume was not found.
698 @retval EFI_SUCCESS The volume was found.
703 PeiFfsFindNextVolume (
704 IN CONST EFI_PEI_SERVICES
**PeiServices
,
706 IN OUT EFI_PEI_FV_HANDLE
*VolumeHandle
709 PEI_CORE_INSTANCE
*Private
;
710 PEI_CORE_FV_HANDLE
*CoreFvHandle
;
712 if (VolumeHandle
== NULL
) {
713 return EFI_INVALID_PARAMETER
;
716 Private
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
718 CoreFvHandle
= FindNextCoreFvHandle (Private
, Instance
);
719 if (CoreFvHandle
== NULL
) {
720 *VolumeHandle
= NULL
;
721 return EFI_NOT_FOUND
;
724 *VolumeHandle
= CoreFvHandle
->FvHandle
;
731 Find a file within a volume by its name.
733 @param FileName A pointer to the name of the file to find within the firmware volume.
734 @param VolumeHandle The firmware volume to search
735 @param FileHandle Upon exit, points to the found file's handle
736 or NULL if it could not be found.
738 @retval EFI_SUCCESS File was found.
739 @retval EFI_NOT_FOUND File was not found.
740 @retval EFI_INVALID_PARAMETER VolumeHandle or FileHandle or FileName was NULL.
745 PeiFfsFindFileByName (
746 IN CONST EFI_GUID
*FileName
,
747 IN EFI_PEI_FV_HANDLE VolumeHandle
,
748 OUT EFI_PEI_FILE_HANDLE
*FileHandle
751 PEI_CORE_FV_HANDLE
*CoreFvHandle
;
753 if ((VolumeHandle
== NULL
) || (FileName
== NULL
) || (FileHandle
== NULL
)) {
754 return EFI_INVALID_PARAMETER
;
757 CoreFvHandle
= FvHandleToCoreHandle (VolumeHandle
);
758 if ((CoreFvHandle
== NULL
) || (CoreFvHandle
->FvPpi
== NULL
)) {
759 return EFI_NOT_FOUND
;
762 return CoreFvHandle
->FvPpi
->FindFileByName (CoreFvHandle
->FvPpi
, FileName
, &VolumeHandle
, FileHandle
);
766 Returns information about a specific file.
768 @param FileHandle Handle of the file.
769 @param FileInfo Upon exit, points to the file's information.
771 @retval EFI_INVALID_PARAMETER If FileInfo is NULL.
772 @retval EFI_INVALID_PARAMETER If FileHandle does not represent a valid file.
773 @retval EFI_SUCCESS File information returned.
779 IN EFI_PEI_FILE_HANDLE FileHandle
,
780 OUT EFI_FV_FILE_INFO
*FileInfo
783 PEI_CORE_FV_HANDLE
*CoreFvHandle
;
785 if ((FileHandle
== NULL
) || (FileInfo
== NULL
)) {
786 return EFI_INVALID_PARAMETER
;
790 // Retrieve the FirmwareVolume which the file resides in.
792 CoreFvHandle
= FileHandleToVolume (FileHandle
);
793 if ((CoreFvHandle
== NULL
) || (CoreFvHandle
->FvPpi
== NULL
)) {
794 return EFI_INVALID_PARAMETER
;
797 return CoreFvHandle
->FvPpi
->GetFileInfo (CoreFvHandle
->FvPpi
, FileHandle
, FileInfo
);
802 Returns information about the specified volume.
804 This function returns information about a specific firmware
805 volume, including its name, type, attributes, starting address
808 @param VolumeHandle Handle of the volume.
809 @param VolumeInfo Upon exit, points to the volume's information.
811 @retval EFI_SUCCESS Volume information returned.
812 @retval EFI_INVALID_PARAMETER If VolumeHandle does not represent a valid volume.
813 @retval EFI_INVALID_PARAMETER If VolumeHandle is NULL.
814 @retval EFI_SUCCESS Information successfully returned.
815 @retval EFI_INVALID_PARAMETER The volume designated by the VolumeHandle is not available.
820 PeiFfsGetVolumeInfo (
821 IN EFI_PEI_FV_HANDLE VolumeHandle
,
822 OUT EFI_FV_INFO
*VolumeInfo
825 PEI_CORE_FV_HANDLE
*CoreHandle
;
827 if ((VolumeInfo
== NULL
) || (VolumeHandle
== NULL
)) {
828 return EFI_INVALID_PARAMETER
;
831 CoreHandle
= FvHandleToCoreHandle (VolumeHandle
);
833 if ((CoreHandle
== NULL
) || (CoreHandle
->FvPpi
== NULL
)) {
834 return EFI_INVALID_PARAMETER
;
837 return CoreHandle
->FvPpi
->GetVolumeInfo (CoreHandle
->FvPpi
, VolumeHandle
, VolumeInfo
);
841 Get Fv image from the FV type file, then install FV INFO ppi, Build FV hob.
843 @param ParentFvCoreHandle Pointer of EFI_CORE_FV_HANDLE to parent Fv image that contain this Fv image.
844 @param ParentFvFileHandle File handle of a Fv type file that contain this Fv image.
846 @retval EFI_NOT_FOUND FV image can't be found.
847 @retval EFI_SUCCESS Successfully to process it.
848 @retval EFI_OUT_OF_RESOURCES Can not allocate page when aligning FV image
849 @retval Others Can not find EFI_SECTION_FIRMWARE_VOLUME_IMAGE section
854 IN PEI_CORE_FV_HANDLE
*ParentFvCoreHandle
,
855 IN EFI_PEI_FILE_HANDLE ParentFvFileHandle
859 EFI_FV_INFO ParentFvImageInfo
;
862 EFI_PEI_HOB_POINTERS HobPtr
;
863 EFI_PEI_FIRMWARE_VOLUME_PPI
*ParentFvPpi
;
864 EFI_PEI_FV_HANDLE ParentFvHandle
;
865 EFI_FIRMWARE_VOLUME_HEADER
*FvHeader
;
866 EFI_FV_FILE_INFO FileInfo
;
870 // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already
873 HobPtr
.Raw
= GetHobList ();
874 while ((HobPtr
.Raw
= GetNextHob (EFI_HOB_TYPE_FV2
, HobPtr
.Raw
)) != NULL
) {
875 if (CompareGuid (&(((EFI_FFS_FILE_HEADER
*)ParentFvFileHandle
)->Name
), &HobPtr
.FirmwareVolume2
->FileName
)) {
877 // this FILE has been dispatched, it will not be dispatched again.
879 DEBUG ((EFI_D_INFO
, "FV file %p has been dispatched!\r\n", ParentFvFileHandle
));
882 HobPtr
.Raw
= GET_NEXT_HOB (HobPtr
);
885 ParentFvHandle
= ParentFvCoreHandle
->FvHandle
;
886 ParentFvPpi
= ParentFvCoreHandle
->FvPpi
;
889 // Find FvImage in FvFile
891 Status
= ParentFvPpi
->FindSectionByType (
893 EFI_SECTION_FIRMWARE_VOLUME_IMAGE
,
898 if (EFI_ERROR (Status
)) {
903 // FvAlignment must be more than 8 bytes required by FvHeader structure.
905 FvAlignment
= 1 << ((ReadUnaligned32 (&FvHeader
->Attributes
) & EFI_FVB2_ALIGNMENT
) >> 16);
906 if (FvAlignment
< 8) {
913 if ((UINTN
) FvHeader
% FvAlignment
!= 0) {
914 FvLength
= ReadUnaligned64 (&FvHeader
->FvLength
);
915 NewFvBuffer
= AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32
) FvLength
), FvAlignment
);
916 if (NewFvBuffer
== NULL
) {
917 return EFI_OUT_OF_RESOURCES
;
919 CopyMem (NewFvBuffer
, FvHeader
, (UINTN
) FvLength
);
920 FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) NewFvBuffer
;
923 Status
= ParentFvPpi
->GetVolumeInfo (ParentFvPpi
, ParentFvHandle
, &ParentFvImageInfo
);
924 ASSERT_EFI_ERROR (Status
);
926 Status
= ParentFvPpi
->GetFileInfo (ParentFvPpi
, ParentFvFileHandle
, &FileInfo
);
927 ASSERT_EFI_ERROR (Status
);
930 // Install FvPpi and Build FvHob
932 PeiServicesInstallFvInfoPpi (
933 &FvHeader
->FileSystemGuid
,
935 (UINT32
) FvHeader
->FvLength
,
936 &ParentFvImageInfo
.FvName
,
941 // Inform the extracted FvImage to Fv HOB consumer phase, i.e. DXE phase
944 (EFI_PHYSICAL_ADDRESS
) (UINTN
) FvHeader
,
949 // Makes the encapsulated volume show up in DXE phase to skip processing of
950 // encapsulated file again.
953 (EFI_PHYSICAL_ADDRESS
) (UINTN
) FvHeader
,
955 &ParentFvImageInfo
.FvName
,
963 Process a firmware volume and create a volume handle.
965 Create a volume handle from the information in the buffer. For
966 memory-mapped firmware volumes, Buffer and BufferSize refer to
967 the start of the firmware volume and the firmware volume size.
968 For non memory-mapped firmware volumes, this points to a
969 buffer which contains the necessary information for creating
970 the firmware volume handle. Normally, these values are derived
971 from the EFI_FIRMWARE_VOLUME_INFO_PPI.
974 @param This Points to this instance of the
975 EFI_PEI_FIRMWARE_VOLUME_PPI.
976 @param Buffer Points to the start of the buffer.
977 @param BufferSize Size of the buffer.
978 @param FvHandle Points to the returned firmware volume
979 handle. The firmware volume handle must
980 be unique within the system.
982 @retval EFI_SUCCESS Firmware volume handle created.
983 @retval EFI_VOLUME_CORRUPTED Volume was corrupt.
988 PeiFfs2FvPpiProcessVolume (
989 IN CONST EFI_PEI_FIRMWARE_VOLUME_PPI
*This
,
992 OUT EFI_PEI_FV_HANDLE
*FvHandle
997 ASSERT (FvHandle
!= NULL
);
999 if (Buffer
== NULL
) {
1000 return EFI_VOLUME_CORRUPTED
;
1004 // The build-in EFI_PEI_FIRMWARE_VOLUME_PPI for FFS2 support memory-mapped
1005 // FV image and the handle is pointed to Fv image's buffer.
1007 *FvHandle
= (EFI_PEI_FV_HANDLE
) Buffer
;
1010 // Do verify for given FV buffer.
1012 Status
= VerifyFv ((EFI_FIRMWARE_VOLUME_HEADER
*) Buffer
);
1013 if (EFI_ERROR(Status
)) {
1014 DEBUG ((EFI_D_ERROR
, "Fail to verify FV which address is 0x%11p", Buffer
));
1015 return EFI_VOLUME_CORRUPTED
;
1022 Finds the next file of the specified type.
1024 This service enables PEI modules to discover additional firmware files.
1025 The FileHandle must be unique within the system.
1027 @param This Points to this instance of the
1028 EFI_PEI_FIRMWARE_VOLUME_PPI.
1029 @param SearchType A filter to find only files of this type. Type
1030 EFI_FV_FILETYPE_ALL causes no filtering to be
1032 @param FvHandle Handle of firmware volume in which to
1034 @param FileHandle Points to the current handle from which to
1035 begin searching or NULL to start at the
1036 beginning of the firmware volume. Updated
1037 upon return to reflect the file found.
1039 @retval EFI_SUCCESS The file was found.
1040 @retval EFI_NOT_FOUND The file was not found. FileHandle contains NULL.
1045 PeiFfs2FvPpiFindFileByType (
1046 IN CONST EFI_PEI_FIRMWARE_VOLUME_PPI
*This
,
1047 IN EFI_FV_FILETYPE SearchType
,
1048 IN EFI_PEI_FV_HANDLE FvHandle
,
1049 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
1052 return FindFileEx (FvHandle
, NULL
, SearchType
, FileHandle
, NULL
);
1056 Find a file within a volume by its name.
1058 This service searches for files with a specific name, within
1059 either the specified firmware volume or all firmware volumes.
1061 @param This Points to this instance of the
1062 EFI_PEI_FIRMWARE_VOLUME_PPI.
1063 @param FileName A pointer to the name of the file to find
1064 within the firmware volume.
1065 @param FvHandle Upon entry, the pointer to the firmware
1066 volume to search or NULL if all firmware
1067 volumes should be searched. Upon exit, the
1068 actual firmware volume in which the file was
1070 @param FileHandle Upon exit, points to the found file's
1071 handle or NULL if it could not be found.
1073 @retval EFI_SUCCESS File was found.
1074 @retval EFI_NOT_FOUND File was not found.
1075 @retval EFI_INVALID_PARAMETER FvHandle or FileHandle or
1082 PeiFfs2FvPpiFindFileByName (
1083 IN CONST EFI_PEI_FIRMWARE_VOLUME_PPI
*This
,
1084 IN CONST EFI_GUID
*FileName
,
1085 IN EFI_PEI_FV_HANDLE
*FvHandle
,
1086 OUT EFI_PEI_FILE_HANDLE
*FileHandle
1090 PEI_CORE_INSTANCE
*PrivateData
;
1093 if ((FvHandle
== NULL
) || (FileName
== NULL
) || (FileHandle
== NULL
)) {
1094 return EFI_INVALID_PARAMETER
;
1097 if (*FvHandle
!= NULL
) {
1098 Status
= FindFileEx (*FvHandle
, FileName
, 0, FileHandle
, NULL
);
1099 if (Status
== EFI_NOT_FOUND
) {
1104 // If *FvHandle = NULL, so search all FV for given filename
1106 Status
= EFI_NOT_FOUND
;
1108 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer());
1109 for (Index
= 0; Index
< PrivateData
->FvCount
; Index
++) {
1111 // Only search the FV which is associated with a EFI_PEI_FIRMWARE_VOLUME_PPI instance.
1113 if (PrivateData
->Fv
[Index
].FvPpi
!= NULL
) {
1114 Status
= FindFileEx (PrivateData
->Fv
[Index
].FvHandle
, FileName
, 0, FileHandle
, NULL
);
1115 if (!EFI_ERROR (Status
)) {
1116 *FvHandle
= PrivateData
->Fv
[Index
].FvHandle
;
1127 Returns information about a specific file.
1129 This function returns information about a specific
1130 file, including its file name, type, attributes, starting
1133 @param This Points to this instance of the
1134 EFI_PEI_FIRMWARE_VOLUME_PPI.
1135 @param FileHandle Handle of the file.
1136 @param FileInfo Upon exit, points to the file's
1139 @retval EFI_SUCCESS File information returned.
1140 @retval EFI_INVALID_PARAMETER If FileHandle does not
1141 represent a valid file.
1142 @retval EFI_INVALID_PARAMETER If FileInfo is NULL.
1147 PeiFfs2FvPpiGetFileInfo (
1148 IN CONST EFI_PEI_FIRMWARE_VOLUME_PPI
*This
,
1149 IN EFI_PEI_FILE_HANDLE FileHandle
,
1150 OUT EFI_FV_FILE_INFO
*FileInfo
1154 UINT8 ErasePolarity
;
1155 EFI_FFS_FILE_HEADER
*FileHeader
;
1156 PEI_CORE_FV_HANDLE
*CoreFvHandle
;
1158 if ((FileHandle
== NULL
) || (FileInfo
== NULL
)) {
1159 return EFI_INVALID_PARAMETER
;
1163 // Retrieve the FirmwareVolume which the file resides in.
1165 CoreFvHandle
= FileHandleToVolume (FileHandle
);
1166 if (CoreFvHandle
== NULL
) {
1167 return EFI_INVALID_PARAMETER
;
1170 if ((CoreFvHandle
->FvHeader
->Attributes
& EFI_FVB2_ERASE_POLARITY
) != 0) {
1177 // Get FileState which is the highest bit of the State
1179 FileState
= GetFileState (ErasePolarity
, (EFI_FFS_FILE_HEADER
*)FileHandle
);
1181 switch (FileState
) {
1182 case EFI_FILE_DATA_VALID
:
1183 case EFI_FILE_MARKED_FOR_UPDATE
:
1186 return EFI_INVALID_PARAMETER
;
1189 FileHeader
= (EFI_FFS_FILE_HEADER
*)FileHandle
;
1190 CopyMem (&FileInfo
->FileName
, &FileHeader
->Name
, sizeof(EFI_GUID
));
1191 FileInfo
->FileType
= FileHeader
->Type
;
1192 FileInfo
->FileAttributes
= FileHeader
->Attributes
;
1193 FileInfo
->BufferSize
= ((*(UINT32
*)FileHeader
->Size
) & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER
);
1194 FileInfo
->Buffer
= (FileHeader
+ 1);
1199 This function returns information about the firmware volume.
1201 @param This Points to this instance of the
1202 EFI_PEI_FIRMWARE_VOLUME_PPI.
1203 @param FvHandle Handle to the firmware handle.
1204 @param VolumeInfo Points to the returned firmware volume
1207 @retval EFI_SUCCESS Information returned successfully.
1208 @retval EFI_INVALID_PARAMETER FvHandle does not indicate a valid
1209 firmware volume or VolumeInfo is NULL.
1214 PeiFfs2FvPpiGetVolumeInfo (
1215 IN CONST EFI_PEI_FIRMWARE_VOLUME_PPI
*This
,
1216 IN EFI_PEI_FV_HANDLE FvHandle
,
1217 OUT EFI_FV_INFO
*VolumeInfo
1220 EFI_FIRMWARE_VOLUME_HEADER FwVolHeader
;
1221 EFI_FIRMWARE_VOLUME_EXT_HEADER
*FwVolExHeaderInfo
;
1223 if ((VolumeInfo
== NULL
) || (FvHandle
== NULL
)) {
1224 return EFI_INVALID_PARAMETER
;
1228 // VolumeHandle may not align at 8 byte,
1229 // but FvLength is UINT64 type, which requires FvHeader align at least 8 byte.
1230 // So, Copy FvHeader into the local FvHeader structure.
1232 CopyMem (&FwVolHeader
, FvHandle
, sizeof (EFI_FIRMWARE_VOLUME_HEADER
));
1235 // Check Fv Image Signature
1237 if (FwVolHeader
.Signature
!= EFI_FVH_SIGNATURE
) {
1238 return EFI_INVALID_PARAMETER
;
1241 ZeroMem (VolumeInfo
, sizeof (EFI_FV_INFO
));
1242 VolumeInfo
->FvAttributes
= FwVolHeader
.Attributes
;
1243 VolumeInfo
->FvStart
= (VOID
*) FvHandle
;
1244 VolumeInfo
->FvSize
= FwVolHeader
.FvLength
;
1245 CopyMem (&VolumeInfo
->FvFormat
, &FwVolHeader
.FileSystemGuid
, sizeof(EFI_GUID
));
1247 if (FwVolHeader
.ExtHeaderOffset
!= 0) {
1248 FwVolExHeaderInfo
= (EFI_FIRMWARE_VOLUME_EXT_HEADER
*)(((UINT8
*)FvHandle
) + FwVolHeader
.ExtHeaderOffset
);
1249 CopyMem (&VolumeInfo
->FvName
, &FwVolExHeaderInfo
->FvName
, sizeof(EFI_GUID
));
1256 Find the next matching section in the firmware file.
1258 This service enables PEI modules to discover sections
1259 of a given type within a valid file.
1261 @param This Points to this instance of the
1262 EFI_PEI_FIRMWARE_VOLUME_PPI.
1263 @param SearchType A filter to find only sections of this
1265 @param FileHandle Handle of firmware file in which to
1267 @param SectionData Updated upon return to point to the
1270 @retval EFI_SUCCESS Section was found.
1271 @retval EFI_NOT_FOUND Section of the specified type was not
1272 found. SectionData contains NULL.
1276 PeiFfs2FvPpiFindSectionByType (
1277 IN CONST EFI_PEI_FIRMWARE_VOLUME_PPI
*This
,
1278 IN EFI_SECTION_TYPE SearchType
,
1279 IN EFI_PEI_FILE_HANDLE FileHandle
,
1280 OUT VOID
**SectionData
1283 EFI_FFS_FILE_HEADER
*FfsFileHeader
;
1285 EFI_COMMON_SECTION_HEADER
*Section
;
1287 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)(FileHandle
);
1290 // Size is 24 bits wide so mask upper 8 bits.
1291 // Does not include FfsFileHeader header size
1292 // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
1294 Section
= (EFI_COMMON_SECTION_HEADER
*)(FfsFileHeader
+ 1);
1295 FileSize
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
1296 FileSize
-= sizeof (EFI_FFS_FILE_HEADER
);
1298 return ProcessSection (
1299 GetPeiServicesTablePointer (),
1308 Convert the handle of FV to pointer of corresponding PEI_CORE_FV_HANDLE.
1310 @param FvHandle The handle of a FV.
1312 @retval NULL if can not find.
1313 @return Pointer of corresponding PEI_CORE_FV_HANDLE.
1315 PEI_CORE_FV_HANDLE
*
1316 FvHandleToCoreHandle (
1317 IN EFI_PEI_FV_HANDLE FvHandle
1321 PEI_CORE_INSTANCE
*PrivateData
;
1323 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer());
1324 for (Index
= 0; Index
< PrivateData
->FvCount
; Index
++) {
1325 if (FvHandle
== PrivateData
->Fv
[Index
].FvHandle
) {
1326 return &PrivateData
->Fv
[Index
];
1334 Get instance of PEI_CORE_FV_HANDLE for next volume according to given index.
1336 This routine also will install FvInfo ppi for FV hob in PI ways.
1338 @param Private Pointer of PEI_CORE_INSTANCE
1339 @param Instance The index of FV want to be searched.
1341 @return Instance of PEI_CORE_FV_HANDLE.
1343 PEI_CORE_FV_HANDLE
*
1344 FindNextCoreFvHandle (
1345 IN PEI_CORE_INSTANCE
*Private
,
1351 EFI_HOB_FIRMWARE_VOLUME
*FvHob
;
1354 // Handle Framework FvHob and Install FvInfo Ppi for it.
1356 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport
)) {
1358 // Loop to search the wanted FirmwareVolume which supports FFS
1360 FvHob
= (EFI_HOB_FIRMWARE_VOLUME
*)GetFirstHob (EFI_HOB_TYPE_FV
);
1361 while (FvHob
!= NULL
) {
1363 // Search whether FvHob has been installed into PeiCore's FV database.
1364 // If found, no need install new FvInfoPpi for it.
1366 for (Index
= 0, Match
= FALSE
; Index
< Private
->FvCount
; Index
++) {
1367 if ((EFI_PEI_FV_HANDLE
)(UINTN
)FvHob
->BaseAddress
== Private
->Fv
[Index
].FvHeader
) {
1374 // Search whether FvHob has been cached into PeiCore's Unknown FV database.
1375 // If found, no need install new FvInfoPpi for it.
1378 for (Index
= 0; Index
< Private
->UnknownFvInfoCount
; Index
++) {
1379 if ((UINTN
)FvHob
->BaseAddress
== (UINTN
)Private
->UnknownFvInfo
[Index
].FvInfo
) {
1387 // If the Fv in FvHob has not been installed into PeiCore's FV database and has
1388 // not been cached into PeiCore's Unknown FV database, install a new FvInfoPpi
1389 // for it then PeiCore will dispatch it in callback of FvInfoPpi.
1392 PeiServicesInstallFvInfoPpi (
1393 &(((EFI_FIRMWARE_VOLUME_HEADER
*)(UINTN
)FvHob
->BaseAddress
)->FileSystemGuid
),
1394 (VOID
*)(UINTN
)FvHob
->BaseAddress
,
1395 (UINT32
)FvHob
->Length
,
1401 FvHob
= (EFI_HOB_FIRMWARE_VOLUME
*)GetNextHob (EFI_HOB_TYPE_FV
, (VOID
*)((UINTN
)FvHob
+ FvHob
->Header
.HobLength
));
1405 ASSERT (Private
->FvCount
<= FixedPcdGet32 (PcdPeiCoreMaxFvSupported
));
1406 if (Instance
>= Private
->FvCount
) {
1410 return &Private
->Fv
[Instance
];
1414 After PeiCore image is shadowed into permanent memory, all build-in FvPpi should
1415 be re-installed with the instance in permanent memory and all cached FvPpi pointers in
1416 PrivateData->Fv[] array should be fixed up to be pointed to the one in permenant
1419 @param PrivateData Pointer to PEI_CORE_INSTANCE.
1423 IN PEI_CORE_INSTANCE
*PrivateData
1427 EFI_PEI_PPI_DESCRIPTOR
*OldDescriptor
;
1432 // Locate old build-in Ffs2 EFI_PEI_FIRMWARE_VOLUME_PPI which
1435 Status
= PeiServicesLocatePpi (
1436 &gEfiFirmwareFileSystem2Guid
,
1441 ASSERT_EFI_ERROR (Status
);
1444 // Re-install the EFI_PEI_FIRMWARE_VOLUME_PPI for build-in Ffs2
1445 // which is shadowed from flash to permanent memory within PeiCore image.
1447 Status
= PeiServicesReInstallPpi (OldDescriptor
, &mPeiFfs2FvPpiList
);
1448 ASSERT_EFI_ERROR (Status
);
1451 // Fixup all FvPpi pointers for the implementation in flash to permanent memory.
1453 for (Index
= 0; Index
< FixedPcdGet32 (PcdPeiCoreMaxFvSupported
); Index
++) {
1454 if (PrivateData
->Fv
[Index
].FvPpi
== OldFfs2FvPpi
) {
1455 PrivateData
->Fv
[Index
].FvPpi
= &mPeiFfs2FvPpi
;
1461 Report the information for a new discoveried FV in unknown third-party format.
1463 If the EFI_PEI_FIRMWARE_VOLUME_PPI has not been installed for third-party FV format, but
1464 the FV in this format has been discoveried, then this FV's information will be cached into
1465 PEI_CORE_INSTANCE's UnknownFvInfo array.
1466 Also a notification would be installed for unknown third-party FV format guid, if EFI_PEI_FIRMWARE_VOLUME_PPI
1467 is installed later by platform's PEIM, the original unknown third-party FV will be processed by
1468 using new installed EFI_PEI_FIRMWARE_VOLUME_PPI.
1470 @param PrivateData Point to instance of PEI_CORE_INSTANCE
1471 @param Format Point to the unknown third-party format guid.
1472 @param FvInfo Point to FvInfo buffer.
1473 @param FvInfoSize The size of FvInfo buffer.
1475 @retval EFI_OUT_OF_RESOURCES The FV info array in PEI_CORE_INSTANCE has no more spaces.
1476 @retval EFI_SUCCESS Success to add the information for unknown FV.
1479 AddUnknownFormatFvInfo (
1480 IN PEI_CORE_INSTANCE
*PrivateData
,
1481 IN EFI_GUID
*Format
,
1483 IN UINT32 FvInfoSize
1486 PEI_CORE_UNKNOW_FORMAT_FV_INFO
*NewUnknownFv
;
1488 if (PrivateData
->UnknownFvInfoCount
+ 1 >= FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)) {
1489 return EFI_OUT_OF_RESOURCES
;
1492 NewUnknownFv
= &PrivateData
->UnknownFvInfo
[PrivateData
->UnknownFvInfoCount
];
1493 PrivateData
->UnknownFvInfoCount
++;
1495 CopyGuid (&NewUnknownFv
->FvFormat
, Format
);
1496 NewUnknownFv
->FvInfo
= FvInfo
;
1497 NewUnknownFv
->FvInfoSize
= FvInfoSize
;
1498 NewUnknownFv
->NotifyDescriptor
.Flags
= (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
);
1499 NewUnknownFv
->NotifyDescriptor
.Guid
= &NewUnknownFv
->FvFormat
;
1500 NewUnknownFv
->NotifyDescriptor
.Notify
= ThirdPartyFvPpiNotifyCallback
;
1502 PeiServicesNotifyPpi (&NewUnknownFv
->NotifyDescriptor
);
1507 Find the FV information according to third-party FV format guid.
1509 This routine also will remove the FV information found by given FV format guid from
1510 PrivateData->UnknownFvInfo[].
1512 @param PrivateData Point to instance of PEI_CORE_INSTANCE
1513 @param Format Point to given FV format guid
1514 @param FvInfo On return, the pointer of FV information buffer
1515 @param FvInfoSize On return, the size of FV information buffer.
1517 @retval EFI_NOT_FOUND The FV is not found for new installed EFI_PEI_FIRMWARE_VOLUME_PPI
1518 @retval EFI_SUCCESS Success to find a FV which could be processed by new installed EFI_PEI_FIRMWARE_VOLUME_PPI.
1521 FindUnknownFormatFvInfo (
1522 IN PEI_CORE_INSTANCE
*PrivateData
,
1523 IN EFI_GUID
*Format
,
1525 OUT UINT32
*FvInfoSize
1532 for (; Index
< PrivateData
->UnknownFvInfoCount
; Index
++) {
1533 if (CompareGuid (Format
, &PrivateData
->UnknownFvInfo
[Index
].FvFormat
)) {
1538 if (Index
== PrivateData
->UnknownFvInfoCount
) {
1539 return EFI_NOT_FOUND
;
1542 *FvInfo
= PrivateData
->UnknownFvInfo
[Index
].FvInfo
;
1543 *FvInfoSize
= PrivateData
->UnknownFvInfo
[Index
].FvInfoSize
;
1546 // Remove an entry from UnknownFvInfo array.
1549 for (;Index2
< PrivateData
->UnknownFvInfoCount
; Index2
++, Index
++) {
1550 CopyMem (&PrivateData
->UnknownFvInfo
[Index
], &PrivateData
->UnknownFvInfo
[Index2
], sizeof (PEI_CORE_UNKNOW_FORMAT_FV_INFO
));
1552 PrivateData
->UnknownFvInfoCount
--;
1557 Notification callback function for EFI_PEI_FIRMWARE_VOLUME_PPI.
1559 When a EFI_PEI_FIRMWARE_VOLUME_PPI is installed to support new FV format, this
1560 routine is called to process all discoveried FVs in this format.
1562 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
1563 @param NotifyDescriptor Address of the notification descriptor data structure.
1564 @param Ppi Address of the PPI that was installed.
1566 @retval EFI_SUCCESS The notification callback is processed correctly.
1570 ThirdPartyFvPpiNotifyCallback (
1571 IN EFI_PEI_SERVICES
**PeiServices
,
1572 IN EFI_PEI_NOTIFY_DESCRIPTOR
*NotifyDescriptor
,
1576 PEI_CORE_INSTANCE
*PrivateData
;
1577 EFI_PEI_FIRMWARE_VOLUME_PPI
*FvPpi
;
1581 EFI_PEI_FV_HANDLE FvHandle
;
1582 BOOLEAN IsProcessed
;
1584 EFI_PEI_FILE_HANDLE FileHandle
;
1587 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
1588 FvPpi
= (EFI_PEI_FIRMWARE_VOLUME_PPI
*) Ppi
;
1591 Status
= FindUnknownFormatFvInfo (PrivateData
, NotifyDescriptor
->Guid
, &FvInfo
, &FvInfoSize
);
1592 if (EFI_ERROR (Status
)) {
1597 // Process new found FV and get FV handle.
1599 Status
= FvPpi
->ProcessVolume (FvPpi
, FvInfo
, FvInfoSize
, &FvHandle
);
1600 if (EFI_ERROR (Status
)) {
1601 DEBUG ((EFI_D_ERROR
, "Fail to process the FV 0x%p, FV may be corrupted!\n", FvInfo
));
1606 // Check whether the FV has already been processed.
1608 IsProcessed
= FALSE
;
1609 for (FvIndex
= 0; FvIndex
< PrivateData
->FvCount
; FvIndex
++) {
1610 if (PrivateData
->Fv
[FvIndex
].FvHandle
== FvHandle
) {
1611 DEBUG ((EFI_D_INFO
, "The Fv %p has already been processed!\n", FvInfo
));
1621 if (PrivateData
->FvCount
>= FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)) {
1622 DEBUG ((EFI_D_ERROR
, "The number of Fv Images (%d) exceed the max supported FVs (%d) in Pei", PrivateData
->FvCount
+ 1, FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)));
1623 DEBUG ((EFI_D_ERROR
, "PcdPeiCoreMaxFvSupported value need be reconfigurated in DSC"));
1628 // Update internal PEI_CORE_FV array.
1630 PrivateData
->Fv
[PrivateData
->FvCount
].FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) FvInfo
;
1631 PrivateData
->Fv
[PrivateData
->FvCount
].FvPpi
= FvPpi
;
1632 PrivateData
->Fv
[PrivateData
->FvCount
].FvHandle
= FvHandle
;
1635 "The %dth FV start address is 0x%11p, size is 0x%08x, handle is 0x%p\n",
1636 (UINT32
) PrivateData
->FvCount
,
1641 PrivateData
->FvCount
++;
1644 // Scan and process the new discoveried FV for EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
1648 Status
= FvPpi
->FindFileByType (
1650 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
,
1654 if (!EFI_ERROR (Status
)) {
1655 Status
= FvPpi
->FindSectionByType (
1657 EFI_SECTION_PEI_DEPEX
,
1661 if (!EFI_ERROR (Status
)) {
1662 if (!PeimDispatchReadiness (PeiServices
, DepexData
)) {
1664 // Dependency is not satisfied.
1670 DEBUG ((EFI_D_INFO
, "Found firmware volume Image File %p in FV[%d] %p\n", FileHandle
, PrivateData
->FvCount
- 1, FvHandle
));
1671 ProcessFvFile (&PrivateData
->Fv
[PrivateData
->FvCount
- 1], FileHandle
);
1673 } while (FileHandle
!= NULL
);