tree e5aa3d0ddb34b6673b77944af7374c93ee493ba9
parent 2c822ab513868bed32e75db7489b5d8a97ae8d7b
author Subrata Banik <subratabanik@google.com> 1661408657 +0530
committer Subrata Banik <subratabanik@google.com> 1661412441 +0000

soc/intel/mtl: Program MCHBASE prior enabling extended bios range

This patch resolves the SoC programming dependency order where enabling
extended bios support requires MCHBASE to be enabled.

BUG=b:243693375
TEST=Able to boot from RW-A slot which is mapped to extended BIOS range.

Signed-off-by: Subrata Banik <subratabanik@google.com>
Change-Id: I8bd9c3d3fb5e82e34f2d6af8548452c744d4b3c5
Reviewed-on: https://review.coreboot.org/c/coreboot/+/67046
Reviewed-by: Kapil Porwal <kapilporwal@google.com>
Reviewed-by: Eric Lai <eric_lai@quanta.corp-partner.google.com>
Reviewed-by: Ivy Jian <ivy.jian@quanta.corp-partner.google.com>
Reviewed-by: Tarun Tuli <taruntuli@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
