Tegra194: add SE support to generate SHA256 of TZRAM
The BL3-1 firmware code is stored in TZSRAM on Tegra194 platforms. This memory loses power when we enter System Suspend and so its contents are stored to TZDRAM, before entry. This opens up an attack vector where the TZDRAM contents might be tampered with when we are in the System Suspend mode. To mitigate this attack the SE engine calculates the hash of entire TZSRAM and stores it in PMC scratch, before we copy data to TZDRAM. The WB0 code will validate the TZDRAM and match the hash with the one in PMC scratch. This patch adds driver for the SE engine, with APIs to calculate the hash and store to PMC scratch registers. Change-Id: I04cc0eb7f54c69d64b6c34fc2ff62e4cfbdd43b2 Signed-off-by: Jeetesh Burman <jburman@nvidia.com>
This commit is contained in:
Jeetesh Burman
Varun Wadekar
parent
2ac7b22387
commit
029dd14e72
|
|
@ -197,6 +197,14 @@
|
|||
* Tegra scratch registers constants
|
||||
******************************************************************************/
|
||||
#define TEGRA_SCRATCH_BASE U(0x0C390000)
|
||||
#define SECURE_SCRATCH_RSV68_LO U(0x284)
|
||||
#define SECURE_SCRATCH_RSV68_HI U(0x288)
|
||||
#define SECURE_SCRATCH_RSV69_LO U(0x28C)
|
||||
#define SECURE_SCRATCH_RSV69_HI U(0x290)
|
||||
#define SECURE_SCRATCH_RSV70_LO U(0x294)
|
||||
#define SECURE_SCRATCH_RSV70_HI U(0x298)
|
||||
#define SECURE_SCRATCH_RSV71_LO U(0x29C)
|
||||
#define SECURE_SCRATCH_RSV71_HI U(0x2A0)
|
||||
#define SECURE_SCRATCH_RSV72_LO U(0x2A4)
|
||||
#define SECURE_SCRATCH_RSV72_HI U(0x2A8)
|
||||
#define SECURE_SCRATCH_RSV75 U(0x2BC)
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
#ifndef SE_H
|
||||
#define SE_H
|
||||
|
||||
int32_t tegra_se_calculate_save_sha256(uint64_t src_addr,
|
||||
uint32_t src_len_inbyte);
|
||||
int32_t tegra_se_suspend(void);
|
||||
void tegra_se_resume(void);
|
||||
|
||||
|
|
|
|||
|
|
@ -28,6 +28,14 @@
|
|||
#define MAX_TIMEOUT_MS U(100) /* Timeout in 100ms */
|
||||
#define NUM_SE_REGS_TO_SAVE U(4)
|
||||
|
||||
#define SE0_MAX_BUSY_TIMEOUT_MS U(100) /* 100ms Timeout Expired */
|
||||
#define BYTES_IN_WORD U(4)
|
||||
#define SHA256_MAX_HASH_RESULT U(7)
|
||||
#define SHA256_DST_SIZE U(32)
|
||||
#define SHA_FIRST_OP U(1)
|
||||
#define MAX_SHA_ENGINE_CHUNK_SIZE U(0xFFFFFF)
|
||||
#define SHA256_MSG_LENGTH_ONETIME U(0xFFFF)
|
||||
|
||||
/*******************************************************************************
|
||||
* Data structure and global variables
|
||||
******************************************************************************/
|
||||
|
|
@ -175,6 +183,270 @@ static int32_t tegra_se_save_context(void)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check that SE operation has completed after kickoff
|
||||
* This function is invoked after an SE operation has been started,
|
||||
* and it checks the following conditions:
|
||||
* 1. SE0_INT_STATUS = SE0_OP_DONE
|
||||
* 2. SE0_STATUS = IDLE
|
||||
* 3. SE0_ERR_STATUS is clean.
|
||||
*/
|
||||
static int32_t tegra_se_sha256_hash_operation_complete(void)
|
||||
{
|
||||
uint32_t val = 0U;
|
||||
|
||||
/* Poll the SE interrupt register to ensure H/W operation complete */
|
||||
val = tegra_se_read_32(SE0_INT_STATUS_REG_OFFSET);
|
||||
while (SE0_INT_OP_DONE(val) == SE0_INT_OP_DONE_CLEAR) {
|
||||
val = tegra_se_read_32(SE0_INT_STATUS_REG_OFFSET);
|
||||
if (SE0_INT_OP_DONE(val) != SE0_INT_OP_DONE_CLEAR) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Poll the SE status idle to ensure H/W operation complete */
|
||||
val = tegra_se_read_32(SE0_SHA_STATUS_0);
|
||||
while (val != SE0_SHA_STATUS_IDLE) {
|
||||
val = tegra_se_read_32(SE0_SHA_STATUS_0);
|
||||
if (val == SE0_SHA_STATUS_IDLE) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Ensure that no errors are thrown during operation */
|
||||
val = tegra_se_read_32(SE0_ERR_STATUS_REG_OFFSET);
|
||||
if (val != 0U) {
|
||||
ERROR("%s: error during SE operation! 0x%x", __func__,
|
||||
val);
|
||||
return -ENOTSUP;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Security engine primitive normal operations
|
||||
*/
|
||||
static int32_t tegra_se_start_normal_operation(uint64_t src_addr,
|
||||
uint32_t nbytes, uint32_t last_buf, uint32_t src_len_inbytes)
|
||||
{
|
||||
uint32_t val = 0U;
|
||||
uint32_t src_in_lo;
|
||||
uint32_t src_in_msb;
|
||||
uint32_t src_in_hi;
|
||||
int32_t ret = 0;
|
||||
|
||||
if ((src_addr == 0ULL) || (nbytes == 0U))
|
||||
return -EINVAL;
|
||||
|
||||
src_in_lo = (uint32_t)src_addr;
|
||||
src_in_msb = (uint32_t)((src_addr >> 32U) & 0xFFU);
|
||||
src_in_hi = ((src_in_msb << SE0_IN_HI_ADDR_HI_0_MSB_SHIFT) |
|
||||
(nbytes & MAX_SHA_ENGINE_CHUNK_SIZE));
|
||||
|
||||
/* set SRC_IN_ADDR_LO and SRC_IN_ADDR_HI*/
|
||||
tegra_se_write_32(SE0_IN_ADDR, src_in_lo);
|
||||
tegra_se_write_32(SE0_IN_HI_ADDR_HI, src_in_hi);
|
||||
|
||||
val = tegra_se_read_32(SE0_INT_STATUS_REG_OFFSET);
|
||||
if (val > 0U) {
|
||||
tegra_se_write_32(SE0_INT_STATUS_REG_OFFSET, 0x0U);
|
||||
}
|
||||
|
||||
/* Enable SHA interrupt for SE0 Operation */
|
||||
tegra_se_write_32(SE0_SHA_INT_ENABLE, 0x1aU);
|
||||
|
||||
/* flush to DRAM for SE to use the updated contents */
|
||||
flush_dcache_range(src_addr, src_len_inbytes);
|
||||
|
||||
/* Start SHA256 operation */
|
||||
if (last_buf == 1U) {
|
||||
tegra_se_write_32(SE0_OPERATION_REG_OFFSET, SE0_OP_START |
|
||||
SE0_UNIT_OPERATION_PKT_LASTBUF_FIELD);
|
||||
} else {
|
||||
tegra_se_write_32(SE0_OPERATION_REG_OFFSET, SE0_OP_START);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int32_t tegra_se_calculate_sha256_hash(uint64_t src_addr,
|
||||
uint32_t src_len_inbyte)
|
||||
{
|
||||
uint32_t val, last_buf, i;
|
||||
int32_t ret = 0;
|
||||
uint32_t operations;
|
||||
uint64_t src_len_inbits;
|
||||
uint32_t len_bits_msb;
|
||||
uint32_t len_bits_lsb;
|
||||
uint32_t number_of_operations, max_bytes, bytes_left, remaining_bytes;
|
||||
|
||||
if (src_len_inbyte > MAX_SHA_ENGINE_CHUNK_SIZE) {
|
||||
ERROR("SHA input chunk size too big: 0x%x\n", src_len_inbyte);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (src_addr == 0ULL) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* number of bytes per operation */
|
||||
max_bytes = (SHA256_HASH_SIZE_BYTES * SHA256_MSG_LENGTH_ONETIME);
|
||||
|
||||
src_len_inbits = (uint32_t)(src_len_inbyte * 8U);
|
||||
len_bits_msb = (uint32_t)(src_len_inbits >> 32U);
|
||||
len_bits_lsb = (uint32_t)src_len_inbits;
|
||||
|
||||
/* program SE0_CONFIG for SHA256 operation */
|
||||
val = (uint32_t)(SE0_CONFIG_ENC_ALG_SHA | SE0_CONFIG_ENC_MODE_SHA256 |
|
||||
SE0_CONFIG_DEC_ALG_NOP | SE0_CONFIG_DST_HASHREG);
|
||||
tegra_se_write_32(SE0_SHA_CONFIG, val);
|
||||
|
||||
/* set SE0_SHA_MSG_LENGTH registers */
|
||||
tegra_se_write_32(SE0_SHA_MSG_LENGTH_0, len_bits_lsb);
|
||||
tegra_se_write_32(SE0_SHA_MSG_LEFT_0, len_bits_lsb);
|
||||
tegra_se_write_32(SE0_SHA_MSG_LENGTH_1, len_bits_msb);
|
||||
|
||||
/* zero out unused SE0_SHA_MSG_LENGTH and SE0_SHA_MSG_LEFT */
|
||||
tegra_se_write_32(SE0_SHA_MSG_LENGTH_2, 0U);
|
||||
tegra_se_write_32(SE0_SHA_MSG_LENGTH_3, 0U);
|
||||
tegra_se_write_32(SE0_SHA_MSG_LEFT_1, 0U);
|
||||
tegra_se_write_32(SE0_SHA_MSG_LEFT_2, 0U);
|
||||
tegra_se_write_32(SE0_SHA_MSG_LEFT_3, 0U);
|
||||
|
||||
number_of_operations = (src_len_inbyte / max_bytes);
|
||||
remaining_bytes = (src_len_inbyte % max_bytes);
|
||||
if (remaining_bytes > 0U) {
|
||||
number_of_operations += 1U;
|
||||
}
|
||||
|
||||
/*
|
||||
* 1. Operations == 1: program SE0_SHA_TASK register to initiate SHA256
|
||||
* hash generation by setting
|
||||
* 1(SE0_SHA_CONFIG_HW_INIT_HASH) to SE0_SHA_TASK
|
||||
* and start SHA256-normal operation.
|
||||
* 2. 1 < Operations < number_of_operations: program SE0_SHA_TASK to
|
||||
* 0(SE0_SHA_CONFIG_HW_INIT_HASH_DISABLE) to load
|
||||
* intermediate SHA256 digest result from
|
||||
* HASH_RESULT register to continue SHA256
|
||||
* generation and start SHA256-normal operation.
|
||||
* 3. Operations == number_of_operations: continue with step 2 and set
|
||||
* max_bytes to bytes_left to process final
|
||||
* hash-result generation and start SHA256-normal
|
||||
* operation.
|
||||
*/
|
||||
bytes_left = src_len_inbyte;
|
||||
for (operations = 1U; operations <= number_of_operations;
|
||||
operations++) {
|
||||
if (operations == SHA_FIRST_OP) {
|
||||
val = SE0_SHA_CONFIG_HW_INIT_HASH;
|
||||
} else {
|
||||
/* Load intermediate SHA digest result to
|
||||
* SHA:HASH_RESULT(0..7) to continue the SHA
|
||||
* calculation and tell the SHA engine to use it.
|
||||
*/
|
||||
for (i = 0U; (i / BYTES_IN_WORD) <=
|
||||
SHA256_MAX_HASH_RESULT; i += BYTES_IN_WORD) {
|
||||
val = tegra_se_read_32(SE0_SHA_HASH_RESULT_0 +
|
||||
i);
|
||||
tegra_se_write_32(SE0_SHA_HASH_RESULT_0 + i,
|
||||
val);
|
||||
}
|
||||
val = SE0_SHA_CONFIG_HW_INIT_HASH_DISABLE;
|
||||
if (len_bits_lsb <= (max_bytes * 8U)) {
|
||||
len_bits_lsb = (remaining_bytes * 8U);
|
||||
} else {
|
||||
len_bits_lsb -= (max_bytes * 8U);
|
||||
}
|
||||
tegra_se_write_32(SE0_SHA_MSG_LEFT_0, len_bits_lsb);
|
||||
}
|
||||
tegra_se_write_32(SE0_SHA_TASK_CONFIG, val);
|
||||
|
||||
max_bytes = (SHA256_HASH_SIZE_BYTES *
|
||||
SHA256_MSG_LENGTH_ONETIME);
|
||||
if (bytes_left < max_bytes) {
|
||||
max_bytes = bytes_left;
|
||||
last_buf = 1U;
|
||||
} else {
|
||||
bytes_left = bytes_left - max_bytes;
|
||||
last_buf = 0U;
|
||||
}
|
||||
/* start operation */
|
||||
ret = tegra_se_start_normal_operation(src_addr, max_bytes,
|
||||
last_buf, src_len_inbyte);
|
||||
if (ret != 0) {
|
||||
ERROR("Error during SE operation! 0x%x", ret);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int32_t tegra_se_save_sha256_pmc_scratch(void)
|
||||
{
|
||||
uint32_t val = 0U, hash_offset = 0U, scratch_offset = 0U;
|
||||
int32_t ret;
|
||||
|
||||
/* Check SE0 operation status */
|
||||
ret = tegra_se_sha256_hash_operation_complete();
|
||||
if (ret != 0) {
|
||||
ERROR("SE operation complete Failed! 0x%x", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (scratch_offset = SECURE_SCRATCH_TZDRAM_SHA256_HASH_START;
|
||||
scratch_offset <= SECURE_SCRATCH_TZDRAM_SHA256_HASH_END;
|
||||
scratch_offset += BYTES_IN_WORD) {
|
||||
val = tegra_se_read_32(SE0_SHA_HASH_RESULT_0 + hash_offset);
|
||||
mmio_write_32((uint32_t)(TEGRA_SCRATCH_BASE + scratch_offset),
|
||||
val);
|
||||
hash_offset += BYTES_IN_WORD;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Handler to generate SHA256 and save HASH-result to pmc-scratch register
|
||||
*/
|
||||
int32_t tegra_se_calculate_save_sha256(uint64_t src_addr,
|
||||
uint32_t src_len_inbyte)
|
||||
{
|
||||
uint32_t security;
|
||||
int32_t val = 0;
|
||||
|
||||
/* Set SE_SOFT_SETTINGS=SE_SECURE to prevent NS process to change SE
|
||||
* registers.
|
||||
*/
|
||||
security = tegra_se_read_32(SE0_SECURITY);
|
||||
tegra_se_write_32(SE0_SECURITY, security | SE0_SECURITY_SE_SOFT_SETTING);
|
||||
|
||||
/* Bootrom enable IN_ID bit in SE0_SHA_GSCID_0 register during SC7-exit, causing
|
||||
* SE0 ignores SE0 operation, and therefore failure of 2nd iteration of SC7 cycle.
|
||||
*/
|
||||
tegra_se_write_32(SE0_SHA_GSCID_0, 0x0U);
|
||||
|
||||
/* Calculate SHA256 of BL31 */
|
||||
val = tegra_se_calculate_sha256_hash(src_addr, src_len_inbyte);
|
||||
if (val != 0) {
|
||||
ERROR("%s: SHA256 generation failed\n", __func__);
|
||||
return val;
|
||||
}
|
||||
|
||||
/*
|
||||
* Reset SE_SECURE to previous value.
|
||||
*/
|
||||
tegra_se_write_32(SE0_SECURITY, security);
|
||||
|
||||
/* copy sha256_dst to PMC Scratch register */
|
||||
val = tegra_se_save_sha256_pmc_scratch();
|
||||
if (val != 0) {
|
||||
ERROR("%s: SE0 status Error.\n", __func__);
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
/*
|
||||
* Handler to power down the SE hardware blocks - SE, RNG1 and PKA1. This
|
||||
* needs to be called only during System Suspend.
|
||||
|
|
|
|||
|
|
@ -9,6 +9,86 @@
|
|||
#define SE_PRIVATE_H
|
||||
|
||||
#include <lib/utils_def.h>
|
||||
#include <tegra_def.h>
|
||||
|
||||
/* SE0 security register */
|
||||
#define SE0_SECURITY U(0x18)
|
||||
#define SE0_SECURITY_SE_SOFT_SETTING (((uint32_t)1) << 16U)
|
||||
|
||||
/* SE0 SHA GSCID register */
|
||||
#define SE0_SHA_GSCID_0 U(0x100)
|
||||
|
||||
/* SE0 config register */
|
||||
#define SE0_SHA_CONFIG U(0x104)
|
||||
#define SE0_SHA_TASK_CONFIG U(0x108)
|
||||
#define SE0_SHA_CONFIG_HW_INIT_HASH (((uint32_t)1) << 0U)
|
||||
#define SE0_SHA_CONFIG_HW_INIT_HASH_DISABLE U(0)
|
||||
|
||||
#define SE0_CONFIG_ENC_ALG_SHIFT U(12)
|
||||
#define SE0_CONFIG_ENC_ALG_SHA \
|
||||
(((uint32_t)3) << SE0_CONFIG_ENC_ALG_SHIFT)
|
||||
#define SE0_CONFIG_DEC_ALG_SHIFT U(8)
|
||||
#define SE0_CONFIG_DEC_ALG_NOP \
|
||||
(((uint32_t)0) << SE0_CONFIG_DEC_ALG_SHIFT)
|
||||
#define SE0_CONFIG_DST_SHIFT U(2)
|
||||
#define SE0_CONFIG_DST_HASHREG \
|
||||
(((uint32_t)1) << SE0_CONFIG_DST_SHIFT)
|
||||
#define SHA256_HASH_SIZE_BYTES U(256)
|
||||
|
||||
#define SE0_CONFIG_ENC_MODE_SHIFT U(24)
|
||||
#define SE0_CONFIG_ENC_MODE_SHA256 \
|
||||
(((uint32_t)5) << SE0_CONFIG_ENC_MODE_SHIFT)
|
||||
|
||||
/* SHA input message length */
|
||||
#define SE0_IN_ADDR U(0x10c)
|
||||
#define SE0_IN_HI_ADDR_HI U(0x110)
|
||||
#define SE0_IN_HI_ADDR_HI_0_MSB_SHIFT U(24)
|
||||
|
||||
/* SHA input message length */
|
||||
#define SE0_SHA_MSG_LENGTH_0 U(0x11c)
|
||||
#define SE0_SHA_MSG_LENGTH_1 U(0x120)
|
||||
#define SE0_SHA_MSG_LENGTH_2 U(0x124)
|
||||
#define SE0_SHA_MSG_LENGTH_3 U(0x128)
|
||||
|
||||
/* SHA input message left */
|
||||
#define SE0_SHA_MSG_LEFT_0 U(0x12c)
|
||||
#define SE0_SHA_MSG_LEFT_1 U(0x130)
|
||||
#define SE0_SHA_MSG_LEFT_2 U(0x134)
|
||||
#define SE0_SHA_MSG_LEFT_3 U(0x138)
|
||||
|
||||
/* SE HASH-RESULT */
|
||||
#define SE0_SHA_HASH_RESULT_0 U(0x13c)
|
||||
|
||||
/* SE OPERATION */
|
||||
#define SE0_OPERATION_REG_OFFSET U(0x17c)
|
||||
#define SE0_UNIT_OPERATION_PKT_LASTBUF_SHIFT U(16)
|
||||
#define SE0_UNIT_OPERATION_PKT_LASTBUF_FIELD \
|
||||
((uint32_t)0x1 << SE0_UNIT_OPERATION_PKT_LASTBUF_SHIFT)
|
||||
#define SE0_OPERATION_SHIFT U(0)
|
||||
#define SE0_OP_START \
|
||||
(((uint32_t)0x1) << SE0_OPERATION_SHIFT)
|
||||
|
||||
/* SE Interrupt */
|
||||
#define SE0_SHA_INT_ENABLE U(0x180)
|
||||
|
||||
#define SE0_INT_STATUS_REG_OFFSET U(0x184)
|
||||
#define SE0_INT_OP_DONE_SHIFT U(4)
|
||||
#define SE0_INT_OP_DONE_CLEAR \
|
||||
(((uint32_t)0U) << SE0_INT_OP_DONE_SHIFT)
|
||||
#define SE0_INT_OP_DONE(x) \
|
||||
((x) & (((uint32_t)0x1U) << SE0_INT_OP_DONE_SHIFT))
|
||||
|
||||
/* SE SHA Status */
|
||||
#define SE0_SHA_STATUS_0 U(0x188)
|
||||
#define SE0_SHA_STATUS_IDLE U(0)
|
||||
|
||||
/* SE error status */
|
||||
#define SE0_ERR_STATUS_REG_OFFSET U(0x18c)
|
||||
#define SE0_ERR_STATUS_CLEAR U(0)
|
||||
|
||||
/* SE error status */
|
||||
#define SECURE_SCRATCH_TZDRAM_SHA256_HASH_START SECURE_SCRATCH_RSV68_LO
|
||||
#define SECURE_SCRATCH_TZDRAM_SHA256_HASH_END SECURE_SCRATCH_RSV71_HI
|
||||
|
||||
/* SE0_INT_ENABLE_0 */
|
||||
#define SE0_INT_ENABLE U(0x88)
|
||||
|
|
@ -20,7 +100,7 @@
|
|||
|
||||
/* SE0_SHA_INT_STATUS_0 */
|
||||
#define SHA_INT_STATUS U(0x184)
|
||||
#define SHA_SE_OP_DONE (U(1) << 4)
|
||||
#define SHA_SE_OP_DONE (U(1) << 4)
|
||||
|
||||
/* SE0_SHA_ERR_STATUS_0 */
|
||||
#define SHA_ERR_STATUS U(0x18C)
|
||||
|
|
|
|||
|
|
@ -10,9 +10,11 @@
|
|||
#include <string.h>
|
||||
|
||||
#include <arch_helpers.h>
|
||||
#include <bpmp_ipc.h>
|
||||
#include <common/bl_common.h>
|
||||
#include <common/debug.h>
|
||||
#include <context.h>
|
||||
#include <drivers/delay_timer.h>
|
||||
#include <denver.h>
|
||||
#include <lib/el3_runtime/context_mgmt.h>
|
||||
#include <lib/psci/psci.h>
|
||||
|
|
@ -289,9 +291,34 @@ int32_t tegra_soc_pwr_domain_power_down_wfi(const psci_power_state_t *target_sta
|
|||
plat_params_from_bl2_t *params_from_bl2 = bl31_get_plat_params();
|
||||
uint8_t stateid_afflvl2 = pwr_domain_state[PLAT_MAX_PWR_LVL] &
|
||||
TEGRA194_STATE_ID_MASK;
|
||||
uint64_t src_len_in_bytes = (uintptr_t)&__BL31_END__ - (uintptr_t)BL31_BASE;
|
||||
uint64_t val;
|
||||
int32_t ret = PSCI_E_SUCCESS;
|
||||
|
||||
if (stateid_afflvl2 == PSTATE_ID_SOC_POWERDN) {
|
||||
val = params_from_bl2->tzdram_base +
|
||||
tegra194_get_cpu_reset_handler_size();
|
||||
|
||||
/* initialise communication channel with BPMP */
|
||||
ret = tegra_bpmp_ipc_init();
|
||||
assert(ret == 0);
|
||||
|
||||
/* Enable SE clock before SE context save */
|
||||
ret = tegra_bpmp_ipc_enable_clock(TEGRA_CLK_SE);
|
||||
assert(ret == 0);
|
||||
|
||||
/*
|
||||
* It is very unlikely that the BL31 image would be
|
||||
* bigger than 2^32 bytes
|
||||
*/
|
||||
assert(src_len_in_bytes < UINT32_MAX);
|
||||
|
||||
if (tegra_se_calculate_save_sha256(BL31_BASE,
|
||||
(uint32_t)src_len_in_bytes) != 0) {
|
||||
ERROR("Hash calculation failed. Reboot\n");
|
||||
(void)tegra_soc_prepare_system_reset();
|
||||
}
|
||||
|
||||
/*
|
||||
* The TZRAM loses power when we enter system suspend. To
|
||||
* allow graceful exit from system suspend, we need to copy
|
||||
|
|
@ -300,10 +327,14 @@ int32_t tegra_soc_pwr_domain_power_down_wfi(const psci_power_state_t *target_sta
|
|||
val = params_from_bl2->tzdram_base +
|
||||
tegra194_get_cpu_reset_handler_size();
|
||||
memcpy((void *)(uintptr_t)val, (void *)(uintptr_t)BL31_BASE,
|
||||
(uintptr_t)&__BL31_END__ - (uintptr_t)BL31_BASE);
|
||||
src_len_in_bytes);
|
||||
|
||||
/* Disable SE clock after SE context save */
|
||||
ret = tegra_bpmp_ipc_disable_clock(TEGRA_CLK_SE);
|
||||
assert(ret == 0);
|
||||
}
|
||||
|
||||
return PSCI_E_SUCCESS;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int32_t tegra_soc_pwr_domain_suspend_pwrdown_early(const psci_power_state_t *target_state)
|
||||
|
|
|
|||
Loading…
Reference in New Issue