tree 63abdfe41a1746dfd5452f030b2ff4646a15ff76
parent b9644352d7717d4f564be90aac6c41bef583d930
author Hsuan Ting Chen <roccochen@chromium.org> 1633579026 +0000
committer Commit Bot <commit-bot@chromium.org> 1633639833 +0000

Revert "2lib: Use ctx flag VB2_CONTEXT_EC_TRUSTED instead of vb2ex_ec_trusted"

This reverts commit 8aded7005e2830f54cf53b329946cbb1f11548f2.

Reason for revert: b:202258389

Original change's description:
> 2lib: Use ctx flag VB2_CONTEXT_EC_TRUSTED instead of vb2ex_ec_trusted
>
> In vb2api_allow_recovery(), we need to check if EC is trusted for
> booting into manual recovery mode. This was implemented by a function
> vb2ex_ec_trusted() which defined in vboot_reference and implemented in
> depthcharge by reading the corresponding EC_IN_RW GPIO flags.
>
> By introducing new boot mode architecture, coreboot will now calling
> these functions to determine the current boot mode and support the
> similar functionalities about checking if EC is trusted (i.e. EC is not
> in RW).
>
> We leverages the existing ctx flag VB2_CONTEXT_EC_TRUSTED for fulfilling
> this. This flag will be set at coreboot vboot_logic.c:verstage_main()
> and can be used deciding the boot mode in vboot_reference:
> vb2api_fw_phase1() and is cleared while EC jumps to RW (i.e.
> 2ec_sync.c:sync_ec()).
>
> BRANCH=none
> BUG=b:181931817
> TEST=emerge-trogdor coreboot vboot_reference depthcharge
>
> Cq-Depend: chromium:3088889
> Signed-off-by: Hsuan Ting Chen <roccochen@chromium.org>
> Change-Id: I50f35f48ce75e421094ea21e45c24b82e6e55a6c
> Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/3106329
> Reviewed-by: Julius Werner <jwerner@chromium.org>
> Reviewed-by: Yu-Ping Wu <yupingso@chromium.org>

Bug: b:181931817
Change-Id: I11ae3b2d71c040dfe45b34f74974845dafa92b42
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/3211007
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Bhanu Prakash Maiya <bhanumaiya@google.com>
