tree 864da294cb6a8adc18004382a91186afffafb179
parent d982274a4ecc8ed6b42724d03332d06d50393109
author Subrata Banik <subratabanik@google.com> 1701351586 +0530
committer Subrata Banik <subratabanik@google.com> 1701670556 +0000

soc/intel/alderlake: Update LidStatus UPD dynamically

This patch ensures that the LidStatus UPD is passed a dynamic value,
rather than always passing 1 (CONFIG_RUN_FSP_GOP enabled) for FSP 2.0
devices.

Problem statement:
* FSP-S GFX PEIM initializes the on-board display (eDP) even when the
  LID is physically closed, because LidStatus is always set to 1.
* FSP-S skips external display initialization even when the LID is
  closed.

Solution:
* FSP-S GFX PEIM module understands the presence of an external display
  if LidStatus is not set, and tries to probe the other display
  endpoint.
* Statically passing LidStatus as always enabled (aka 1) does not
  illustrate the exact device scenarios, so this patch updates
  LidStatus dynamically by reading the EC memory map offset.

BUG=b:313886118
TEST=Able to build and boot google/marasov to redirect the display
using external HDMI monitor while LID is closed.

Change-Id: Idb1d71bd54837630f36d43a45effc53d35f9cb70
Signed-off-by: Subrata Banik <subratabanik@google.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/79352
Reviewed-by: Eric Lai <ericllai@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
