tree d1c778534938e0dcefdcc8927480707123ceb835
parent f9919574f4f6afb69e39aa6aca39856bdbcf9900
author Dinesh Gehlot <digehlot@google.com> 1676900481 +0000
committer Lean Sheng Tan <sheng.tan@9elements.com> 1677239798 +0000

soc/intel/jsl: Select CSE defined ME spec version for jasperlake

Jasperlake based SoCs uses Intel's Management Engine (ME), version 13.
This patch selects ME 13 specification defined at common code and
removes jasperlake SoC specific ME code and data structures.

BUG=b:260309647

Signed-off-by: Dinesh Gehlot <digehlot@google.com>
Change-Id: Icf4bc651e94d6ec977ed8f2381d7184337dc1ea5
Reviewed-on: https://review.coreboot.org/c/coreboot/+/73139
Reviewed-by: Lean Sheng Tan <sheng.tan@9elements.com>
Reviewed-by: Subrata Banik <subratabanik@google.com>
Reviewed-by: Kapil Porwal <kapilporwal@google.com>
Reviewed-by: Tarun Tuli <taruntuli@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
