soc/intel/cse: Make cse_bp_info response global
PSR data is created and stored in CSE data partition. In platforms that
employ CSE Lite SKU firmware, a firmware downgrade involves clearing of
CSE data partition which results in PSR data being lost.
CSE Lite SKU firmware supports a command to backup PSR data before
initiating a firmware downgrade. PSR data backup command works only
after memory has been initialized. Moving only the downgrade would add
complexity of splitting the cse_fw_sync across pre-RAM and post-RAM
stages. So the idea is to move cse_fw_sync into ramstage when PSR is
enabled.
We are introducing a flow to get CSE boot partition info in early
romstage and then same data will be stored in cbmem once DRAM is
initialized. The CSE BP info data in cbmem will be utilized in early
ramstage to perform cse firmware sync operations. This helps in avoiding
re-sending the CSE get boot partition info command in ramstage. Having
cse_bp_info_rsp as global helps in de-linking cse_get_bp_info from
cse_fw_sync.
Many functions take cse_bp_info as input parameter. Since
cse_bp_info_rsp is global now, we can make use of global cse_bp_info and
remove it as input parameter from those functions.
BUG=b:273207144
TEST=Verify cse_bp_info_rsp holds value across the stage.
Change-Id: I0ee050b49fcae574882378b94329c36a228e6815
Signed-off-by: Krishna Prasad Bhat <krishna.p.bhat.d@intel.com>
Signed-off-by: Rizwan Qureshi <rizwan.qureshi@intel.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/77070
Reviewed-by: sridhar siricilla <siricillasridhar@gmail.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Anil Kumar K <anil.kumar.k@intel.com>
diff --git a/src/soc/intel/common/block/cse/cse_lite.c b/src/soc/intel/common/block/cse/cse_lite.c
index 7b31a74..6a5d55b 100644
--- a/src/soc/intel/common/block/cse/cse_lite.c
+++ b/src/soc/intel/common/block/cse/cse_lite.c
@@ -135,6 +135,8 @@
struct cse_bp_info bp_info;
} __packed;
+static struct get_bp_info_rsp cse_bp_info_rsp;
+
enum cse_fw_state {
/* The CMOS and CBMEM have the current fw version. */
CSE_FW_WARM_BOOT,
@@ -202,15 +204,20 @@
return CB_SUCCESS;
}
-
-static uint8_t cse_get_current_bp(const struct cse_bp_info *cse_bp_info)
+static const struct cse_bp_info *cse_get_bp_info_from_rsp(void)
{
+ return &cse_bp_info_rsp.bp_info;
+}
+
+static uint8_t cse_get_current_bp(void)
+{
+ const struct cse_bp_info *cse_bp_info = cse_get_bp_info_from_rsp();
return cse_bp_info->current_bp;
}
-static const struct cse_bp_entry *cse_get_bp_entry(enum boot_partition_id bp,
- const struct cse_bp_info *cse_bp_info)
+static const struct cse_bp_entry *cse_get_bp_entry(enum boot_partition_id bp)
{
+ const struct cse_bp_info *cse_bp_info = cse_get_bp_info_from_rsp();
return &cse_bp_info->bp_entries[bp];
}
@@ -358,9 +365,10 @@
CBMEM_CREATION_HOOK(preram_cse_info_sync_to_cbmem);
#endif
-static void cse_print_boot_partition_info(const struct cse_bp_info *cse_bp_info)
+static void cse_print_boot_partition_info(void)
{
const struct cse_bp_entry *cse_bp;
+ const struct cse_bp_info *cse_bp_info = cse_get_bp_info_from_rsp();
printk(BIOS_DEBUG, "cse_lite: Number of partitions = %d\n",
cse_bp_info->total_number_of_bp);
@@ -370,14 +378,14 @@
printk(BIOS_DEBUG, "cse_lite: Flags = 0x%x\n", cse_bp_info->flags);
/* Log version info of RO & RW partitions */
- cse_bp = cse_get_bp_entry(RO, cse_bp_info);
+ cse_bp = cse_get_bp_entry(RO);
printk(BIOS_DEBUG, "cse_lite: %s version = %d.%d.%d.%d (Status=0x%x, Start=0x%x, End=0x%x)\n",
GET_BP_STR(RO), cse_bp->fw_ver.major, cse_bp->fw_ver.minor,
cse_bp->fw_ver.hotfix, cse_bp->fw_ver.build,
cse_bp->status, cse_bp->start_offset,
cse_bp->end_offset);
- cse_bp = cse_get_bp_entry(RW, cse_bp_info);
+ cse_bp = cse_get_bp_entry(RW);
printk(BIOS_DEBUG, "cse_lite: %s version = %d.%d.%d.%d (Status=0x%x, Start=0x%x, End=0x%x)\n",
GET_BP_STR(RW), cse_bp->fw_ver.major, cse_bp->fw_ver.minor,
cse_bp->fw_ver.hotfix, cse_bp->fw_ver.build,
@@ -413,7 +421,7 @@
return false;
}
-static enum cb_err cse_get_bp_info(struct get_bp_info_rsp *bp_info_rsp)
+static enum cb_err cse_get_bp_info(void)
{
struct get_bp_info_req {
struct mkhi_hdr hdr;
@@ -433,19 +441,19 @@
size_t resp_size = sizeof(struct get_bp_info_rsp);
- if (heci_send_receive(&info_req, sizeof(info_req), bp_info_rsp, &resp_size,
+ if (heci_send_receive(&info_req, sizeof(info_req), &cse_bp_info_rsp, &resp_size,
HECI_MKHI_ADDR)) {
printk(BIOS_ERR, "cse_lite: Could not get partition info\n");
return CB_ERR;
}
- if (bp_info_rsp->hdr.result) {
+ if (cse_bp_info_rsp.hdr.result) {
printk(BIOS_ERR, "cse_lite: Get partition info resp failed: %d\n",
- bp_info_rsp->hdr.result);
+ cse_bp_info_rsp.hdr.result);
return CB_ERR;
}
- cse_print_boot_partition_info(&bp_info_rsp->bp_info);
+ cse_print_boot_partition_info();
return CB_SUCCESS;
}
@@ -499,7 +507,7 @@
return CB_SUCCESS;
}
-static enum cb_err cse_data_clear_request(const struct cse_bp_info *cse_bp_info)
+static enum cb_err cse_data_clear_request(void)
{
struct data_clr_request {
struct mkhi_hdr hdr;
@@ -513,7 +521,7 @@
};
if (!cse_is_hfs1_cws_normal() || !cse_is_hfs1_com_soft_temp_disable() ||
- cse_get_current_bp(cse_bp_info) != RO) {
+ cse_get_current_bp() != RO) {
printk(BIOS_ERR, "cse_lite: CSE doesn't meet DATA CLEAR cmd prerequisites\n");
return CB_ERR;
}
@@ -565,20 +573,20 @@
return CB_ERR;
}
-static enum cb_err cse_boot_to_rw(const struct cse_bp_info *cse_bp_info)
+static enum cb_err cse_boot_to_rw(void)
{
- if (cse_get_current_bp(cse_bp_info) == RW)
+ if (cse_get_current_bp() == RW)
return CB_SUCCESS;
return cse_set_and_boot_from_next_bp(RW);
}
/* Check if CSE RW data partition is valid or not */
-static bool cse_is_rw_dp_valid(const struct cse_bp_info *cse_bp_info)
+static bool cse_is_rw_dp_valid(void)
{
const struct cse_bp_entry *rw_bp;
- rw_bp = cse_get_bp_entry(RW, cse_bp_info);
+ rw_bp = cse_get_bp_entry(RW);
return rw_bp->status != BP_STATUS_DATA_FAILURE;
}
@@ -586,7 +594,7 @@
* It returns true if RW partition doesn't indicate BP_STATUS_DATA_FAILURE
* otherwise false if any operation fails.
*/
-static enum cb_err cse_fix_data_failure_err(const struct cse_bp_info *cse_bp_info)
+static enum cb_err cse_fix_data_failure_err(void)
{
/*
* If RW partition status indicates BP_STATUS_DATA_FAILURE,
@@ -594,35 +602,34 @@
* - Send SET BOOT PARTITION INFO(RW) command to set CSE's next partition
* - Issue GLOBAL RESET HECI command.
*/
- if (cse_is_rw_dp_valid(cse_bp_info))
+ if (cse_is_rw_dp_valid())
return CB_SUCCESS;
- if (cse_data_clear_request(cse_bp_info) != CB_SUCCESS)
+ if (cse_data_clear_request() != CB_SUCCESS)
return CB_ERR;
- return cse_boot_to_rw(cse_bp_info);
+ return cse_boot_to_rw();
}
-static const struct fw_version *cse_get_bp_entry_version(enum boot_partition_id bp,
- const struct cse_bp_info *bp_info)
+static const struct fw_version *cse_get_bp_entry_version(enum boot_partition_id bp)
{
const struct cse_bp_entry *cse_bp;
- cse_bp = cse_get_bp_entry(bp, bp_info);
+ cse_bp = cse_get_bp_entry(bp);
return &cse_bp->fw_ver;
}
-static const struct fw_version *cse_get_rw_version(const struct cse_bp_info *cse_bp_info)
+static const struct fw_version *cse_get_rw_version(void)
{
- return cse_get_bp_entry_version(RW, cse_bp_info);
+ return cse_get_bp_entry_version(RW);
}
-static void cse_get_bp_entry_range(const struct cse_bp_info *cse_bp_info,
- enum boot_partition_id bp, uint32_t *start_offset, uint32_t *end_offset)
+static void cse_get_bp_entry_range(enum boot_partition_id bp, uint32_t *start_offset,
+ uint32_t *end_offset)
{
const struct cse_bp_entry *cse_bp;
- cse_bp = cse_get_bp_entry(bp, cse_bp_info);
+ cse_bp = cse_get_bp_entry(bp);
if (start_offset)
*start_offset = cse_bp->start_offset;
@@ -632,11 +639,11 @@
}
-static bool cse_is_rw_bp_status_valid(const struct cse_bp_info *cse_bp_info)
+static bool cse_is_rw_bp_status_valid(void)
{
const struct cse_bp_entry *rw_bp;
- rw_bp = cse_get_bp_entry(RW, cse_bp_info);
+ rw_bp = cse_get_bp_entry(RW);
if (rw_bp->status == BP_STATUS_PARTITION_NOT_PRESENT ||
rw_bp->status == BP_STATUS_GENERAL_FAILURE) {
@@ -646,9 +653,9 @@
return true;
}
-static enum cb_err cse_boot_to_ro(const struct cse_bp_info *cse_bp_info)
+static enum cb_err cse_boot_to_ro(void)
{
- if (cse_get_current_bp(cse_bp_info) == RO)
+ if (cse_get_current_bp() == RO)
return CB_SUCCESS;
return cse_set_and_boot_from_next_bp(RO);
@@ -677,8 +684,7 @@
return cse_bp_sign == CSE_RW_SIGNATURE;
}
-static enum cb_err cse_get_target_rdev(const struct cse_bp_info *cse_bp_info,
- struct region_device *target_rdev)
+static enum cb_err cse_get_target_rdev(struct region_device *target_rdev)
{
struct region_device cse_region_rdev;
size_t size;
@@ -688,7 +694,7 @@
if (cse_get_rw_rdev(&cse_region_rdev) != CB_SUCCESS)
return CB_ERR;
- cse_get_bp_entry_range(cse_bp_info, RW, &start_offset, &end_offset);
+ cse_get_bp_entry_range(RW, &start_offset, &end_offset);
size = end_offset + 1 - start_offset;
if (rdev_chain(target_rdev, &cse_region_rdev, start_offset, size))
@@ -822,8 +828,7 @@
return CB_SUCCESS;
}
-static enum cse_update_status cse_check_update_status(const struct cse_bp_info *cse_bp_info,
- struct region_device *target_rdev)
+static enum cse_update_status cse_check_update_status(struct region_device *target_rdev)
{
int ret;
struct fw_version cbfs_rw_version;
@@ -840,7 +845,7 @@
cbfs_rw_version.hotfix,
cbfs_rw_version.build);
- ret = cse_compare_sub_part_version(&cbfs_rw_version, cse_get_rw_version(cse_bp_info));
+ ret = cse_compare_sub_part_version(&cbfs_rw_version, cse_get_rw_version());
if (ret == 0)
return CSE_UPDATE_NOT_REQUIRED;
else if (ret < 0)
@@ -882,8 +887,7 @@
return true;
}
-static enum csme_failure_reason cse_update_rw(const struct cse_bp_info *cse_bp_info,
- const void *cse_cbfs_rw, const size_t cse_blob_sz,
+static enum csme_failure_reason cse_update_rw(const void *cse_cbfs_rw, const size_t cse_blob_sz,
struct region_device *target_rdev)
{
if (region_device_sz(target_rdev) < cse_blob_sz) {
@@ -901,19 +905,18 @@
return CSE_NO_ERROR;
}
-static enum cb_err cse_prep_for_rw_update(const struct cse_bp_info *cse_bp_info,
- enum cse_update_status status)
+static enum cb_err cse_prep_for_rw_update(enum cse_update_status status)
{
/*
* To set CSE's operation mode to HMRFPO mode:
* 1. Ensure CSE to boot from RO(BP1)
* 2. Send HMRFPO_ENABLE command to CSE
*/
- if (cse_boot_to_ro(cse_bp_info) != CB_SUCCESS)
+ if (cse_boot_to_ro() != CB_SUCCESS)
return CB_ERR;
if ((status == CSE_UPDATE_DOWNGRADE) || (status == CSE_UPDATE_CORRUPTED)) {
- if (cse_data_clear_request(cse_bp_info) != CB_SUCCESS) {
+ if (cse_data_clear_request() != CB_SUCCESS) {
printk(BIOS_ERR, "cse_lite: CSE data clear failed!\n");
return CB_ERR;
}
@@ -922,9 +925,8 @@
return cse_hmrfpo_enable();
}
-static enum csme_failure_reason cse_trigger_fw_update(const struct cse_bp_info *cse_bp_info,
- enum cse_update_status status,
- struct region_device *target_rdev)
+static enum csme_failure_reason cse_trigger_fw_update(enum cse_update_status status,
+ struct region_device *target_rdev)
{
enum csme_failure_reason rv;
uint8_t *cbfs_rw_hash;
@@ -960,13 +962,13 @@
goto error_exit;
}
- if (cse_prep_for_rw_update(cse_bp_info, status) != CB_SUCCESS) {
+ if (cse_prep_for_rw_update(status) != CB_SUCCESS) {
rv = CSE_COMMUNICATION_ERROR;
goto error_exit;
}
cse_fw_update_misc_oper();
- rv = cse_update_rw(cse_bp_info, cse_cbfs_rw, size, target_rdev);
+ rv = cse_update_rw(cse_cbfs_rw, size, target_rdev);
error_exit:
cbfs_unmap(cbfs_rw_hash);
@@ -974,24 +976,24 @@
return rv;
}
-static uint8_t cse_fw_update(const struct cse_bp_info *cse_bp_info)
+static uint8_t cse_fw_update(void)
{
struct region_device target_rdev;
enum cse_update_status status;
- if (cse_get_target_rdev(cse_bp_info, &target_rdev) != CB_SUCCESS) {
+ if (cse_get_target_rdev(&target_rdev) != CB_SUCCESS) {
printk(BIOS_ERR, "cse_lite: Failed to get CSE RW Partition\n");
return CSE_LITE_SKU_RW_ACCESS_ERROR;
}
- status = cse_check_update_status(cse_bp_info, &target_rdev);
+ status = cse_check_update_status(&target_rdev);
if (status == CSE_UPDATE_NOT_REQUIRED)
return CSE_NO_ERROR;
if (status == CSE_UPDATE_METADATA_ERROR)
return CSE_LITE_SKU_RW_METADATA_NOT_FOUND;
printk(BIOS_DEBUG, "cse_lite: CSE RW update is initiated\n");
- return cse_trigger_fw_update(cse_bp_info, status, &target_rdev);
+ return cse_trigger_fw_update(status, &target_rdev);
}
static const char *cse_sub_part_str(enum bpdt_entry_type type)
@@ -1006,8 +1008,7 @@
}
}
-static enum cb_err cse_locate_area_as_rdev_rw(const struct cse_bp_info *cse_bp_info,
- size_t bp, struct region_device *cse_rdev)
+static enum cb_err cse_locate_area_as_rdev_rw(size_t bp, struct region_device *cse_rdev)
{
struct region_device cse_region_rdev;
uint32_t size;
@@ -1018,9 +1019,9 @@
return CB_ERR;
if (!strcmp(cse_regions[bp], "RO"))
- cse_get_bp_entry_range(cse_bp_info, RO, &start_offset, &end_offset);
+ cse_get_bp_entry_range(RO, &start_offset, &end_offset);
else
- cse_get_bp_entry_range(cse_bp_info, RW, &start_offset, &end_offset);
+ cse_get_bp_entry_range(RW, &start_offset, &end_offset);
size = end_offset + 1 - start_offset;
@@ -1032,15 +1033,15 @@
return CB_SUCCESS;
}
-static enum cb_err cse_sub_part_get_target_rdev(const struct cse_bp_info *cse_bp_info,
- struct region_device *target_rdev, size_t bp, enum bpdt_entry_type type)
+static enum cb_err cse_sub_part_get_target_rdev(struct region_device *target_rdev, size_t bp,
+ enum bpdt_entry_type type)
{
struct bpdt_header bpdt_hdr;
struct region_device cse_rdev;
struct bpdt_entry bpdt_entries[MAX_SUBPARTS];
uint8_t i;
- if (cse_locate_area_as_rdev_rw(cse_bp_info, bp, &cse_rdev) != CB_SUCCESS) {
+ if (cse_locate_area_as_rdev_rw(bp, &cse_rdev) != CB_SUCCESS) {
printk(BIOS_ERR, "cse_lite: Failed to locate %s in the CSE Region\n",
cse_regions[bp]);
return CB_ERR;
@@ -1121,14 +1122,14 @@
fw_ver->build = man_hdr->binary_version.build;
}
-static enum cb_err cse_prep_for_component_update(const struct cse_bp_info *cse_bp_info)
+static enum cb_err cse_prep_for_component_update(void)
{
/*
* To set CSE's operation mode to HMRFPO mode:
* 1. Ensure CSE to boot from RO(BP1)
* 2. Send HMRFPO_ENABLE command to CSE
*/
- if (cse_boot_to_ro(cse_bp_info) != CB_SUCCESS)
+ if (cse_boot_to_ro() != CB_SUCCESS)
return CB_ERR;
return cse_hmrfpo_enable();
@@ -1173,7 +1174,7 @@
}
static enum csme_failure_reason cse_sub_part_fw_component_update(enum bpdt_entry_type type,
- const struct cse_bp_info *cse_bp_info, const char *name)
+ const char *name)
{
struct region_device target_rdev;
struct fw_version target_fw_ver, source_fw_ver;
@@ -1194,7 +1195,7 @@
/* Trigger sub-partition update in CSE RO and CSE RW */
for (size_t bp = 0; bp < ARRAY_SIZE(cse_regions); bp++) {
- if (cse_sub_part_get_target_rdev(cse_bp_info, &target_rdev, bp, type) != CB_SUCCESS) {
+ if (cse_sub_part_get_target_rdev(&target_rdev, bp, type) != CB_SUCCESS) {
rv = CSE_LITE_SKU_SUB_PART_ACCESS_ERR;
goto error_exit;
}
@@ -1218,7 +1219,7 @@
printk(BIOS_INFO, "CSE %s %s Update initiated\n", GET_BP_STR(bp),
cse_sub_part_str(type));
- if (cse_prep_for_component_update(cse_bp_info) != CB_SUCCESS) {
+ if (cse_prep_for_component_update() != CB_SUCCESS) {
rv = CSE_LITE_SKU_SUB_PART_ACCESS_ERR;
goto error_exit;
}
@@ -1234,7 +1235,7 @@
return rv;
}
-static enum csme_failure_reason cse_sub_part_fw_update(const struct cse_bp_info *cse_bp_info)
+static enum csme_failure_reason cse_sub_part_fw_update(void)
{
if (skip_cse_sub_part_update()) {
printk(BIOS_INFO, "CSE Sub-partition update not required\n");
@@ -1242,21 +1243,17 @@
}
enum csme_failure_reason rv;
- rv = cse_sub_part_fw_component_update(IOM_FW, cse_bp_info,
- CONFIG_SOC_INTEL_CSE_IOM_CBFS_NAME);
+ rv = cse_sub_part_fw_component_update(IOM_FW, CONFIG_SOC_INTEL_CSE_IOM_CBFS_NAME);
handle_cse_sub_part_fw_update_rv(rv);
- rv = cse_sub_part_fw_component_update(NPHY_FW, cse_bp_info,
- CONFIG_SOC_INTEL_CSE_NPHY_CBFS_NAME);
+ rv = cse_sub_part_fw_component_update(NPHY_FW, CONFIG_SOC_INTEL_CSE_NPHY_CBFS_NAME);
return handle_cse_sub_part_fw_update_rv(rv);
}
static void do_cse_fw_sync(void)
{
- static struct get_bp_info_rsp cse_bp_info;
-
/*
* If system is in recovery mode, skip CSE Lite update if CSE sub-partition update
* is not enabled and continue to update CSE sub-partitions.
@@ -1272,7 +1269,7 @@
return;
}
- if (cse_get_bp_info(&cse_bp_info) != CB_SUCCESS) {
+ if (cse_get_bp_info() != CB_SUCCESS) {
printk(BIOS_ERR, "cse_lite: Failed to get CSE boot partition info\n");
/* If system is in recovery mode, don't trigger recovery again */
@@ -1287,12 +1284,11 @@
/*
* If system is in recovery mode, CSE Lite update has to be skipped but CSE
- * sub-partitions like NPHY and IOM have to be updated. If CSE sub-parition update
+ * sub-partitions like NPHY and IOM have to be updated. If CSE sub-partition update
* fails during recovery, just continue to boot.
*/
if (CONFIG(SOC_INTEL_CSE_SUB_PART_UPDATE) && vboot_recovery_mode_enabled()) {
- if (cse_sub_part_fw_update(&cse_bp_info.bp_info) ==
- CSE_LITE_SKU_PART_UPDATE_SUCCESS) {
+ if (cse_sub_part_fw_update() == CSE_LITE_SKU_PART_UPDATE_SUCCESS) {
cse_board_reset();
do_global_reset();
die("ERROR: GLOBAL RESET Failed to reset the system\n");
@@ -1301,7 +1297,7 @@
return;
}
- if (cse_fix_data_failure_err(&cse_bp_info.bp_info) != CB_SUCCESS)
+ if (cse_fix_data_failure_err() != CB_SUCCESS)
cse_trigger_vboot_recovery(CSE_LITE_SKU_DATA_WIPE_ERROR);
/*
@@ -1311,18 +1307,18 @@
*/
if (is_cse_fw_update_enabled()) {
uint8_t rv;
- rv = cse_fw_update(&cse_bp_info.bp_info);
+ rv = cse_fw_update();
if (rv)
cse_trigger_vboot_recovery(rv);
}
if (CONFIG(SOC_INTEL_CSE_SUB_PART_UPDATE))
- cse_sub_part_fw_update(&cse_bp_info.bp_info);
+ cse_sub_part_fw_update();
- if (!cse_is_rw_bp_status_valid(&cse_bp_info.bp_info))
+ if (!cse_is_rw_bp_status_valid())
cse_trigger_vboot_recovery(CSE_LITE_SKU_RW_JUMP_ERROR);
- if (cse_boot_to_rw(&cse_bp_info.bp_info) != CB_SUCCESS) {
+ if (cse_boot_to_rw() != CB_SUCCESS) {
printk(BIOS_ERR, "cse_lite: Failed to switch to RW\n");
cse_trigger_vboot_recovery(CSE_LITE_SKU_RW_SWITCH_ERROR);
}