tree 379172e54cd2bd99d662e1a149b3515b071999bb
parent ecb4e315318e20fe6b708288f5663e40bf7860ce
author Karthikeyan Ramasubramanian <kramasub@google.com> 1671141425 -0700
committer Martin L Roth <gaumless@gmail.com> 1671909017 +0000

soc/amd/mendocino: Split the EFS from the AMDFW body

Contents of unsigned AMDFW in RW sections are verified twice in PSP
verstage - first time by vboot verifying the firmware body, second time
by CBFS verification while the file is loaded to update PSP about the
boot region. This redundant verification adds to boot time. Minimize the
redundancy by splitting the EFS header from the AMDFW body and keep them
as 2 separate CBFS files. This helps to improve the boot time by another
25 ms.

BUG=None
TEST=Build Skyrim BIOS image and boot to OS. Observe boot time
improvement of ~25ms.
Before:
   6:end of verified boot              363,676 (16)
  11:start of bootblock                641,392 (277,716)
After:
   6:end of verified boot              361,655 (16)
  11:start of bootblock                616,967 (255,312)

Change-Id: Ib18a4f5c6781e5a7868e9395c0f1212da0823100
Signed-off-by: Karthikeyan Ramasubramanian <kramasub@google.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/70839
Reviewed-by: Raul Rangel <rrangel@chromium.org>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
