sravan/system76-coreboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

drivers/tpm: Make temp test value naming consistent

Browse Source 
Make naming convention consistent across all functions return values.

BUG=b:296439237
TEST=Boot to OS on Skyrim
BRANCH=None

Change-Id: If86805b39048800276ab90b7687644ec2a0d4bee
Signed-off-by: Jon Murphy <jpmurphy@google.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/77536
Reviewed-by: Yu-Ping Wu <yupingso@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Karthik Ramasubramanian <kramasub@google.com>
Reviewed-by: Eric Lai <eric_lai@quanta.corp-partner.google.com>
This commit is contained in:
Jon Murphy
2023-09-05 10:37:05 -06:00
committed by Karthik Ramasubramanian
parent 277db94ebb
commit 2460481025
17 changed files with 299 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/drivers/crb/tis.c
View File

@@ -122,14 +122,14 @@ static int tpm_get_cap(uint32_t property, uint32_t *value)
{
TPMS_CAPABILITY_DATA cap_data;
int i;
uint32_t status;
uint32_t rc;
if (!value)
return -1;
status = tlcl_get_capability(TPM_CAP_TPM_PROPERTIES, property, 1, &cap_data);
rc = tlcl_get_capability(TPM_CAP_TPM_PROPERTIES, property, 1, &cap_data);
if (status)
if (rc)
return -1;
for (i = 0 ; i < cap_data.data.tpmProperties.count; i++) {

8
src/drivers/i2c/tpm/cr50.c
View File

@@ -132,7 +132,7 @@ static int cr50_i2c_write(uint8_t addr, const uint8_t *buffer, size_t len)
static int process_reset(void)
{
struct stopwatch sw;
int rv = 0;
int rc = 0;
uint8_t access;
/*
@@ -148,9 +148,9 @@ static int process_reset(void)
const uint8_t mask =
TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY;
rv = cr50_i2c_read(TPM_ACCESS(0),
rc = cr50_i2c_read(TPM_ACCESS(0),
&access, sizeof(access));
if (rv || ((access & mask) == mask)) {
if (rc || ((access & mask) == mask)) {
/*
* Don't bombard the chip with traffic, let it keep
* processing the command.
@@ -165,7 +165,7 @@ static int process_reset(void)
return 0;
} while (!stopwatch_expired(&sw));
if (rv)
if (rc)
printk(BIOS_ERR, "Failed to read TPM\n");
else
printk(BIOS_ERR,

10
src/mainboard/facebook/fbg1701/romstage.c
View File

@@ -73,7 +73,7 @@ static const uint8_t crtm_version[] =
int mb_crtm(void)
{
int status = TPM_E_IOERROR;
int rc = TPM_E_IOERROR;
TCG_PCR_EVENT2_HDR tcgEventHdr;
/* Use FirmwareVersion string to represent CRTM version. */
@@ -84,13 +84,13 @@ int mb_crtm(void)
tcgEventHdr.eventSize = sizeof(crtm_version);
printk(BIOS_DEBUG, "%s: EventSize - %u\n", __func__, tcgEventHdr.eventSize);
status = mboot_hash_extend_log(0, (uint8_t *)crtm_version,
rc = mboot_hash_extend_log(0, (uint8_t *)crtm_version,
tcgEventHdr.eventSize, &tcgEventHdr,
(uint8_t *)crtm_version);
if (status) {
printk(BIOS_DEBUG, "Measure CRTM Version returned 0x%x\n", status);
if (rc) {
printk(BIOS_DEBUG, "Measure CRTM Version returned 0x%x\n", rc);
}
return status;
return rc;
}
#endif

8
src/mainboard/google/brya/mainboard.c
View File

@@ -34,11 +34,11 @@ static void mainboard_smbios_strings(struct device *dev, struct smbios_type11 *t
void mainboard_update_soc_chip_config(struct soc_intel_alderlake_config *config)
{
int ret;
int rc;
ret = tlcl_lib_init();
if (ret != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", ret);
rc = tlcl_lib_init();
if (rc != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", rc);
return;
}

8
src/mainboard/google/dedede/mainboard.c
View File

@@ -14,11 +14,11 @@
static void mainboard_update_soc_chip_config(void)
{
struct soc_intel_jasperlake_config *cfg = config_of_soc();
int ret;
int rc;
ret = tlcl_lib_init();
if (ret != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", ret);
rc = tlcl_lib_init();
if (rc != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", rc);
return;
}

8
src/mainboard/google/volteer/mainboard.c
View File

@@ -82,7 +82,7 @@ static void mainboard_enable(struct device *dev)
void mainboard_update_soc_chip_config(struct soc_intel_tigerlake_config *cfg)
{
int ret;
int rc;
if (!CONFIG(TPM_GOOGLE_CR50) || !CONFIG(SPI_TPM)) {
/*
* Negotiation of long interrupt pulses is only supported via SPI. I2C is only
@@ -93,9 +93,9 @@ void mainboard_update_soc_chip_config(struct soc_intel_tigerlake_config *cfg)
return;
}
ret = tlcl_lib_init();
if (ret != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", ret);
rc = tlcl_lib_init();
if (rc != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", rc);
return;
}

6
src/security/tpm/tspi/crtm.c
View File

@@ -192,11 +192,11 @@ int tspi_measure_cache_to_pcr(void)
i = 0;
while (!tpm_log_get(i++, &pcr, &digest_data, &digest_algo, &event_name)) {
printk(BIOS_DEBUG, "TPM: Write digest for %s into PCR %d\n", event_name, pcr);
int result = tlcl_extend(pcr, digest_data, digest_algo);
if (result != TPM_SUCCESS) {
int rc = tlcl_extend(pcr, digest_data, digest_algo);
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR,
"TPM: Writing digest of %s into PCR failed with error %d\n",
event_name, result);
event_name, rc);
return VB2_ERROR_UNKNOWN;
}
}

116
src/security/tpm/tspi/tspi.c
View File

@@ -15,49 +15,49 @@ static uint32_t tpm1_invoke_state_machine(void)
{
uint8_t disabled;
uint8_t deactivated;
uint32_t result = TPM_SUCCESS;
uint32_t rc = TPM_SUCCESS;
/* Check that the TPM is enabled and activated. */
result = tlcl_get_flags(&disabled, &deactivated, NULL);
if (result != TPM_SUCCESS) {
rc = tlcl_get_flags(&disabled, &deactivated, NULL);
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't read capabilities.\n");
return result;
return rc;
}
if (disabled) {
printk(BIOS_INFO, "TPM: is disabled. Enabling...\n");
result = tlcl_set_enable();
if (result != TPM_SUCCESS) {
rc = tlcl_set_enable();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't set enabled state.\n");
return result;
return rc;
}
}
if (!!deactivated != CONFIG(TPM_DEACTIVATE)) {
printk(BIOS_INFO,
"TPM: Unexpected TPM deactivated state. Toggling...\n");
result = tlcl_set_deactivated(!deactivated);
if (result != TPM_SUCCESS) {
rc = tlcl_set_deactivated(!deactivated);
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR,
"TPM: Can't toggle deactivated state.\n");
return result;
return rc;
}
deactivated = !deactivated;
result = TPM_E_MUST_REBOOT;
rc = TPM_E_MUST_REBOOT;
}
return result;
return rc;
}
#endif
static uint32_t tpm_setup_s3_helper(void)
{
uint32_t result;
uint32_t rc;
result = tlcl_resume();
switch (result) {
rc = tlcl_resume();
switch (rc) {
case TPM_SUCCESS:
break;
@@ -67,25 +67,25 @@ static uint32_t tpm_setup_s3_helper(void)
* in S3, so it's already initialized.
*/
printk(BIOS_INFO, "TPM: Already initialized.\n");
result = TPM_SUCCESS;
rc = TPM_SUCCESS;
break;
default:
printk(BIOS_ERR, "TPM: Resume failed (%#x).\n", result);
printk(BIOS_ERR, "TPM: Resume failed (%#x).\n", rc);
break;
}
return result;
return rc;
}
static uint32_t tpm_setup_epilogue(uint32_t result)
static uint32_t tpm_setup_epilogue(uint32_t rc)
{
if (result != TPM_SUCCESS)
if (rc != TPM_SUCCESS)
post_code(POSTCODE_TPM_FAILURE);
else
printk(BIOS_INFO, "TPM: setup succeeded\n");
return result;
return rc;
}
static int tpm_is_setup;
@@ -135,12 +135,12 @@ static inline int tspi_tpm_is_setup(void)
*/
uint32_t tpm_setup(int s3flag)
{
uint32_t result;
uint32_t rc;
result = tlcl_lib_init();
if (result != TPM_SUCCESS) {
rc = tlcl_lib_init();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't initialize.\n");
return tpm_setup_epilogue(result);
return tpm_setup_epilogue(rc);
}
/* Handle special init for S3 resume path */
@@ -149,69 +149,69 @@ uint32_t tpm_setup(int s3flag)
return tpm_setup_epilogue(tpm_setup_s3_helper());
}
result = tlcl_startup();
rc = tlcl_startup();
if (CONFIG(TPM_STARTUP_IGNORE_POSTINIT)
&& result == TPM_E_INVALID_POSTINIT) {
&& rc == TPM_E_INVALID_POSTINIT) {
printk(BIOS_DEBUG, "TPM: ignoring invalid POSTINIT\n");
result = TPM_SUCCESS;
rc = TPM_SUCCESS;
}
if (result != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't run startup command.\n");
return tpm_setup_epilogue(result);
return tpm_setup_epilogue(rc);
}
result = tlcl_assert_physical_presence();
if (result != TPM_SUCCESS) {
rc = tlcl_assert_physical_presence();
if (rc != TPM_SUCCESS) {
/*
* It is possible that the TPM was delivered with the physical
* presence command disabled. This tries enabling it, then
* tries asserting PP again.
*/
result = tlcl_physical_presence_cmd_enable();
if (result != TPM_SUCCESS) {
rc = tlcl_physical_presence_cmd_enable();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't enable physical presence command.\n");
return tpm_setup_epilogue(result);
return tpm_setup_epilogue(rc);
}
result = tlcl_assert_physical_presence();
if (result != TPM_SUCCESS) {
rc = tlcl_assert_physical_presence();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't assert physical presence.\n");
return tpm_setup_epilogue(result);
return tpm_setup_epilogue(rc);
}
}
#if CONFIG(TPM1)
result = tpm1_invoke_state_machine();
rc = tpm1_invoke_state_machine();
#endif
if (CONFIG(TPM_MEASURED_BOOT))
result = tspi_measure_cache_to_pcr();
rc = tspi_measure_cache_to_pcr();
tpm_is_setup = 1;
return tpm_setup_epilogue(result);
return tpm_setup_epilogue(rc);
}
uint32_t tpm_clear_and_reenable(void)
{
uint32_t result;
uint32_t rc;
printk(BIOS_INFO, "TPM: Clear and re-enable\n");
result = tlcl_force_clear();
if (result != TPM_SUCCESS) {
rc = tlcl_force_clear();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't initiate a force clear.\n");
return result;
return rc;
}
#if CONFIG(TPM1)
result = tlcl_set_enable();
if (result != TPM_SUCCESS) {
rc = tlcl_set_enable();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't set enabled state.\n");
return result;
return rc;
}
result = tlcl_set_deactivated(0);
if (result != TPM_SUCCESS) {
rc = tlcl_set_deactivated(0);
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't set deactivated state.\n");
return result;
return rc;
}
#endif
@@ -221,24 +221,24 @@ uint32_t tpm_clear_and_reenable(void)
uint32_t tpm_extend_pcr(int pcr, enum vb2_hash_algorithm digest_algo,
const uint8_t *digest, size_t digest_len, const char *name)
{
uint32_t result;
uint32_t rc;
if (!digest)
return TPM_E_IOERROR;
if (tspi_tpm_is_setup()) {
result = tlcl_lib_init();
if (result != TPM_SUCCESS) {
rc = tlcl_lib_init();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Can't initialize library.\n");
return result;
return rc;
}
printk(BIOS_DEBUG, "TPM: Extending digest for `%s` into PCR %d\n", name, pcr);
result = tlcl_extend(pcr, digest, digest_algo);
if (result != TPM_SUCCESS) {
rc = tlcl_extend(pcr, digest, digest_algo);
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Extending hash for `%s` into PCR %d failed.\n",
name, pcr);
return result;
return rc;
}
}

72
src/security/tpm/tss/tcg-1.2/tss.c
View File

@@ -57,9 +57,9 @@ static inline int tpm_command_size(const uint8_t *buffer)
/* Gets the code field of a TPM command. */
static inline int tpm_command_code(const uint8_t *buffer)
{
uint32_t code;
from_tpm_uint32(buffer + sizeof(uint16_t) + sizeof(uint32_t), &code);
return code;
uint32_t rc;
from_tpm_uint32(buffer + sizeof(uint16_t) + sizeof(uint32_t), &rc);
return rc;
}
/* Gets the return code field of a TPM result. */
@@ -76,27 +76,27 @@ static uint32_t tlcl_send_receive_no_retry(const uint8_t *request,
uint8_t *response, int max_length)
{
uint32_t response_length = max_length;
uint32_t result;
uint32_t rc;
result = tpm_send_receive(request, tpm_command_size(request),
rc = tpm_send_receive(request, tpm_command_size(request),
response, &response_length);
if (result != 0) {
if (rc != 0) {
/* Communication with TPM failed, so response is garbage */
VBDEBUG("TPM: command 0x%x send/receive failed: 0x%x\n",
tpm_command_code(request), result);
return result;
tpm_command_code(request), rc);
return rc;
}
/* Otherwise, use the result code from the response */
result = tpm_return_code(response);
rc = tpm_return_code(response);
/* TODO: add paranoia about returned response_length vs. max_length
* (and possibly expected length from the response header). See
* crosbug.com/17017 */
VBDEBUG("TPM: command 0x%x returned 0x%x\n",
tpm_command_code(request), result);
tpm_command_code(request), rc);
return result;
return rc;
}
/* Sends a TPM command and gets a response. Returns 0 if success or the TPM
@@ -104,17 +104,17 @@ return result;
uint32_t tlcl_send_receive(const uint8_t *request, uint8_t *response,
int max_length)
{
uint32_t result = tlcl_send_receive_no_retry(request, response,
uint32_t rc = tlcl_send_receive_no_retry(request, response,
max_length);
/* If the command fails because the self test has not completed, try it
* again after attempting to ensure that the self test has completed. */
if (result == TPM_E_NEEDS_SELFTEST || result == TPM_E_DOING_SELFTEST) {
result = tlcl_continue_self_test();
if (result != TPM_SUCCESS)
return result;
if (rc == TPM_E_NEEDS_SELFTEST || rc == TPM_E_DOING_SELFTEST) {
rc = tlcl_continue_self_test();
if (rc != TPM_SUCCESS)
return rc;
#if defined(TPM_BLOCKING_CONTINUESELFTEST) || defined(VB_RECOVERY_MODE)
/* Retry only once */
result = tlcl_send_receive_no_retry(request, response,
rc = tlcl_send_receive_no_retry(request, response,
max_length);
#else
/* This needs serious testing. The TPM specification says: "iii.
@@ -123,12 +123,12 @@ uint32_t tlcl_send_receive(const uint8_t *request, uint8_t *response,
* ContinueSelfTest is non-blocking, how do we know that the
* actions have completed other than trying again? */
do {
result = tlcl_send_receive_no_retry(request, response,
rc = tlcl_send_receive_no_retry(request, response,
max_length);
} while (result == TPM_E_DOING_SELFTEST);
} while (rc == TPM_E_DOING_SELFTEST);
#endif
}
return result;
return rc;
}
/* Sends a command and returns the error code. */
@@ -226,15 +226,15 @@ uint32_t tlcl_read(uint32_t index, void *data, uint32_t length)
struct s_tpm_nv_read_cmd cmd;
uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
uint32_t result_length;
uint32_t result;
uint32_t rc;
VBDEBUG("TPM: %s(0x%x, %d)\n", __func__, index, length);
memcpy(&cmd, &tpm_nv_read_cmd, sizeof(cmd));
to_tpm_uint32(cmd.buffer + tpm_nv_read_cmd.index, index);
to_tpm_uint32(cmd.buffer + tpm_nv_read_cmd.length, length);
result = tlcl_send_receive(cmd.buffer, response, sizeof(response));
if (result == TPM_SUCCESS && length > 0) {
rc = tlcl_send_receive(cmd.buffer, response, sizeof(response));
if (rc == TPM_SUCCESS && length > 0) {
uint8_t *nv_read_cursor = response + kTpmResponseHeaderLength;
from_tpm_uint32(nv_read_cursor, &result_length);
if (result_length > length)
@@ -243,7 +243,7 @@ uint32_t tlcl_read(uint32_t index, void *data, uint32_t length)
memcpy(data, nv_read_cursor, result_length);
}
return result;
return rc;
}
uint32_t tlcl_assert_physical_presence(void)
@@ -295,24 +295,24 @@ uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS *pflags)
{
uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
uint32_t size;
uint32_t result = tlcl_send_receive(tpm_getflags_cmd.buffer, response,
uint32_t rc = tlcl_send_receive(tpm_getflags_cmd.buffer, response,
sizeof(response));
if (result != TPM_SUCCESS)
return result;
if (rc != TPM_SUCCESS)
return rc;
from_tpm_uint32(response + kTpmResponseHeaderLength, &size);
if (size != sizeof(TPM_PERMANENT_FLAGS))
return TPM_E_IOERROR;
memcpy(pflags, response + kTpmResponseHeaderLength + sizeof(size),
sizeof(TPM_PERMANENT_FLAGS));
return result;
return rc;
}
uint32_t tlcl_get_flags(uint8_t *disable, uint8_t *deactivated,
uint8_t *nvlocked)
{
TPM_PERMANENT_FLAGS pflags;
uint32_t result = tlcl_get_permanent_flags(&pflags);
if (result == TPM_SUCCESS) {
uint32_t rc = tlcl_get_permanent_flags(&pflags);
if (rc == TPM_SUCCESS) {
if (disable)
*disable = pflags.disable;
if (deactivated)
@@ -322,7 +322,7 @@ uint32_t tlcl_get_flags(uint8_t *disable, uint8_t *deactivated,
VBDEBUG("TPM: flags disable=%d, deactivated=%d, nvlocked=%d\n",
pflags.disable, pflags.deactivated, pflags.nvLocked);
}
return result;
return rc;
}
uint32_t tlcl_set_global_lock(void)
@@ -352,16 +352,16 @@ uint32_t tlcl_get_permissions(uint32_t index, uint32_t *permissions)
struct s_tpm_getpermissions_cmd cmd;
uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
uint8_t *nvdata;
uint32_t result;
uint32_t rc;
uint32_t size;
memcpy(&cmd, &tpm_getpermissions_cmd, sizeof(cmd));
to_tpm_uint32(cmd.buffer + tpm_getpermissions_cmd.index, index);
result = tlcl_send_receive(cmd.buffer, response, sizeof(response));
if (result != TPM_SUCCESS)
return result;
rc = tlcl_send_receive(cmd.buffer, response, sizeof(response));
if (rc != TPM_SUCCESS)
return rc;
nvdata = response + kTpmResponseHeaderLength + sizeof(size);
from_tpm_uint32(nvdata + kNvDataPublicPermissionsOffset, permissions);
return result;
return rc;
}

148
src/security/vboot/secdata_tpm.c
View File

@@ -18,11 +18,11 @@
printk(BIOS_INFO, "%s():%d: " format, __func__, __LINE__, ## args)
#define RETURN_ON_FAILURE(tpm_cmd) do { \
uint32_t result_; \
if ((result_ = (tpm_cmd)) != TPM_SUCCESS) { \
uint32_t rc_; \
if ((rc_ = (tpm_cmd)) != TPM_SUCCESS) { \
VBDEBUG("Antirollback: %08x returned by " #tpm_cmd \
"\n", (int)result_); \
return result_; \
"\n", (int)rc_); \
return rc_; \
} \
} while (0)
@@ -51,17 +51,17 @@ uint32_t antirollback_read_space_kernel(struct vb2_context *ctx)
}
uint8_t size = VB2_SECDATA_KERNEL_SIZE;
uint32_t ret;
uint32_t rc;
/* Start with the version 1.0 size used by all modern Cr50/Ti50 boards. */
ret = tlcl_read(KERNEL_NV_INDEX, ctx->secdata_kernel, size);
if (ret == TPM_E_RANGE) {
rc = tlcl_read(KERNEL_NV_INDEX, ctx->secdata_kernel, size);
if (rc == TPM_E_RANGE) {
/* Fallback to version 0.2(minimum) size and re-read. */
VBDEBUG("Antirollback: NV read out of range, trying min size\n");
size = VB2_SECDATA_KERNEL_MIN_SIZE;
ret = tlcl_read(KERNEL_NV_INDEX, ctx->secdata_kernel, size);
rc = tlcl_read(KERNEL_NV_INDEX, ctx->secdata_kernel, size);
}
RETURN_ON_FAILURE(ret);
RETURN_ON_FAILURE(rc);
if (vb2api_secdata_kernel_check(ctx, &size) == VB2_ERROR_SECDATA_KERNEL_INCOMPLETE)
/* Re-read. vboot will run the check and handle errors. */
@@ -206,11 +206,11 @@ static uint32_t define_space(const char *name, uint32_t index, uint32_t length,
const TPMA_NV nv_attributes,
const uint8_t *nv_policy, size_t nv_policy_size)
{
uint32_t rv;
uint32_t rc;
rv = tlcl_define_space(index, length, nv_attributes, nv_policy,
rc = tlcl_define_space(index, length, nv_attributes, nv_policy,
nv_policy_size);
if (rv == TPM_E_NV_DEFINED) {
if (rc == TPM_E_NV_DEFINED) {
/*
* Continue with writing: it may be defined, but not written
* to. In that case a subsequent tlcl_read() would still return
@@ -220,10 +220,10 @@ static uint32_t define_space(const char *name, uint32_t index, uint32_t length,
* in writing once again even if it was written already.
*/
VBDEBUG("%s: %s space already exists\n", __func__, name);
rv = TPM_SUCCESS;
rc = TPM_SUCCESS;
}
return rv;
return rc;
}
/* Nothing special in the TPM2 path yet. */
@@ -236,12 +236,12 @@ static uint32_t setup_space(const char *name, uint32_t index, const void *data,
uint32_t length, const TPMA_NV nv_attributes,
const uint8_t *nv_policy, size_t nv_policy_size)
{
uint32_t rv;
uint32_t rc;
rv = define_space(name, index, length, nv_attributes, nv_policy,
rc = define_space(name, index, length, nv_attributes, nv_policy,
nv_policy_size);
if (rv != TPM_SUCCESS)
return rv;
if (rc != TPM_SUCCESS)
return rc;
return safe_write(index, data, length);
}
@@ -291,7 +291,7 @@ static uint32_t set_mrc_hash_space(uint32_t index, const uint8_t *data)
*/
static uint32_t setup_zte_spaces(void)
{
uint32_t rv;
uint32_t rc;
uint64_t rma_bytes_counter_default = 0;
uint8_t rma_sn_bits_default[16];
uint8_t board_id_default[12];
@@ -302,47 +302,47 @@ static uint32_t setup_zte_spaces(void)
memset(board_id_default, 0xFF, ARRAY_SIZE(board_id_default));
/* Set up RMA + SN Bits */
rv = setup_space("RMA + SN Bits", ZTE_RMA_SN_BITS_INDEX,
rc = setup_space("RMA + SN Bits", ZTE_RMA_SN_BITS_INDEX,
rma_sn_bits_default, sizeof(rma_sn_bits_default),
zte_attr,
unsatisfiable_policy, sizeof(unsatisfiable_policy));
if (rv != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
VBDEBUG("%s: Failed to set up RMA + SN Bits space\n", __func__);
return rv;
return rc;
}
rv = setup_space("Board ID", ZTE_BOARD_ID_NV_INDEX,
rc = setup_space("Board ID", ZTE_BOARD_ID_NV_INDEX,
board_id_default, sizeof(board_id_default),
zte_attr,
unsatisfiable_policy, sizeof(unsatisfiable_policy));
if (rv != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
VBDEBUG("%s: Failed to set up Board ID space\n", __func__);
return rv;
return rc;
}
/* Set up RMA Bytes counter */
rv = define_space("RMA Bytes Counter", ZTE_RMA_BYTES_COUNTER_INDEX,
rc = define_space("RMA Bytes Counter", ZTE_RMA_BYTES_COUNTER_INDEX,
sizeof(rma_bytes_counter_default),
zte_rma_bytes_attr,
unsatisfiable_policy, sizeof(unsatisfiable_policy));
if (rv != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
VBDEBUG("%s: Failed to define RMA Bytes space\n", __func__);
return rv;
return rc;
}
/*
* Since the RMA counter has the BITS attribute, we need to call
* TPM2_NV_SetBits() in order to initialize it.
*/
rv = tlcl_set_bits(ZTE_RMA_BYTES_COUNTER_INDEX,
rc = tlcl_set_bits(ZTE_RMA_BYTES_COUNTER_INDEX,
rma_bytes_counter_default);
if (rv != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
VBDEBUG("%s: Failed to init RMA Bytes counter space\n",
__func__);
return rv;
return rc;
}
return rv;
return rc;
}
/*
@@ -363,13 +363,17 @@ static uint32_t enterprise_rollback_create_space(void)
static uint32_t setup_widevine_counter_spaces(void)
{
uint32_t index, rv;
uint32_t index, rc;
for (index = 0; index < NUM_WIDEVINE_COUNTERS; index++) {
rv = define_space(WIDEVINE_COUNTER_NAME, WIDEVINE_COUNTER_NV_INDEX(index),
WIDEVINE_COUNTER_SIZE, rw_orderly_counter_attributes, NULL, 0);
if (rv != TPM_SUCCESS)
return rv;
rc = define_space(WIDEVINE_COUNTER_NAME,
WIDEVINE_COUNTER_NV_INDEX(index),
WIDEVINE_COUNTER_SIZE,
rw_orderly_counter_attributes,
NULL,
0);
if (rc != TPM_SUCCESS)
return rc;
}
return TPM_SUCCESS;
}
@@ -443,7 +447,7 @@ uint32_t antirollback_read_space_mrc_hash(uint32_t index, uint8_t *data, uint32_
uint32_t antirollback_write_space_mrc_hash(uint32_t index, const uint8_t *data, uint32_t size)
{
uint8_t spc_data[HASH_NV_SIZE];
uint32_t rv;
uint32_t rc;
if (size != HASH_NV_SIZE) {
VBDEBUG("TPM: Incorrect buffer size for hash idx 0x%x. "
@@ -452,8 +456,8 @@ uint32_t antirollback_write_space_mrc_hash(uint32_t index, const uint8_t *data,
return TPM_E_WRITE_FAILURE;
}
rv = read_space_mrc_hash(index, spc_data);
if (rv == TPM_E_BADINDEX) {
rc = read_space_mrc_hash(index, spc_data);
if (rc == TPM_E_BADINDEX) {
/*
* If space is not defined already for hash, define
* new space.
@@ -462,8 +466,8 @@ uint32_t antirollback_write_space_mrc_hash(uint32_t index, const uint8_t *data,
return set_mrc_hash_space(index, data);
}
if (rv != TPM_SUCCESS)
return rv;
if (rc != TPM_SUCCESS)
return rc;
return safe_write(index, data, size);
}
@@ -493,7 +497,7 @@ uint32_t antirollback_read_space_vbios_hash(uint8_t *data, uint32_t size)
uint32_t antirollback_write_space_vbios_hash(const uint8_t *data, uint32_t size)
{
uint8_t spc_data[HASH_NV_SIZE];
uint32_t rv;
uint32_t rc;
if (size != HASH_NV_SIZE) {
VBDEBUG("TPM: Incorrect buffer size for hash idx 0x%x. "
@@ -502,8 +506,8 @@ uint32_t antirollback_write_space_vbios_hash(const uint8_t *data, uint32_t size)
return TPM_E_WRITE_FAILURE;
}
rv = read_space_vbios_hash(spc_data);
if (rv == TPM_E_BADINDEX) {
rc = read_space_vbios_hash(spc_data);
if (rc == TPM_E_BADINDEX) {
/*
* If space is not defined already for hash, define
* new space.
@@ -513,8 +517,8 @@ uint32_t antirollback_write_space_vbios_hash(const uint8_t *data, uint32_t size)
rw_space_attributes, NULL, 0);
}
if (rv != TPM_SUCCESS)
return rv;
if (rc != TPM_SUCCESS)
return rc;
return safe_write(VBIOS_CACHE_NV_INDEX, data, size);
}
@@ -530,12 +534,12 @@ uint32_t antirollback_write_space_vbios_hash(const uint8_t *data, uint32_t size)
static uint32_t safe_write(uint32_t index, const void *data, uint32_t length)
{
uint32_t result = tlcl_write(index, data, length);
if (result == TPM_E_MAXNVWRITES) {
uint32_t rc = tlcl_write(index, data, length);
if (rc == TPM_E_MAXNVWRITES) {
RETURN_ON_FAILURE(tpm_clear_and_reenable());
return tlcl_write(index, data, length);
} else {
return result;
return rc;
}
}
@@ -547,26 +551,26 @@ static uint32_t safe_write(uint32_t index, const void *data, uint32_t length)
*/
static uint32_t safe_define_space(uint32_t index, uint32_t perm, uint32_t size)
{
uint32_t result = tlcl_define_space(index, perm, size);
if (result == TPM_E_MAXNVWRITES) {
uint32_t rc = tlcl_define_space(index, perm, size);
if (rc == TPM_E_MAXNVWRITES) {
RETURN_ON_FAILURE(tpm_clear_and_reenable());
return tlcl_define_space(index, perm, size);
} else {
return result;
return rc;
}
}
static uint32_t _factory_initialize_tpm(struct vb2_context *ctx)
{
TPM_PERMANENT_FLAGS pflags;
uint32_t result;
uint32_t rc;
vb2api_secdata_firmware_create(ctx);
vb2api_secdata_kernel_create_v0(ctx);
result = tlcl_get_permanent_flags(&pflags);
if (result != TPM_SUCCESS)
return result;
rc = tlcl_get_permanent_flags(&pflags);
if (rc != TPM_SUCCESS)
return rc;
/*
* TPM may come from the factory without physical presence finalized.
@@ -630,7 +634,7 @@ uint32_t antirollback_lock_space_firmware(void)
*/
static uint32_t factory_initialize_tpm(struct vb2_context *ctx)
{
uint32_t result;
uint32_t rc;
VBDEBUG("TPM: factory initialization\n");
@@ -642,13 +646,13 @@ static uint32_t factory_initialize_tpm(struct vb2_context *ctx)
* test---specifically the ones that set lifetime flags, and are only
* executed once per physical TPM.
*/
result = tlcl_self_test_full();
if (result != TPM_SUCCESS)
return result;
rc = tlcl_self_test_full();
if (rc != TPM_SUCCESS)
return rc;
result = _factory_initialize_tpm(ctx);
if (result != TPM_SUCCESS)
return result;
rc = _factory_initialize_tpm(ctx);
if (rc != TPM_SUCCESS)
return rc;
/* _factory_initialize_tpm() writes initial secdata values to TPM
immediately, so let vboot know that it's up to date now. */
@@ -662,15 +666,15 @@ static uint32_t factory_initialize_tpm(struct vb2_context *ctx)
uint32_t antirollback_read_space_firmware(struct vb2_context *ctx)
{
uint32_t rv;
uint32_t rc;
rv = tlcl_read(FIRMWARE_NV_INDEX, ctx->secdata_firmware, VB2_SECDATA_FIRMWARE_SIZE);
if (rv == TPM_E_BADINDEX) {
rc = tlcl_read(FIRMWARE_NV_INDEX, ctx->secdata_firmware, VB2_SECDATA_FIRMWARE_SIZE);
if (rc == TPM_E_BADINDEX) {
/* This seems the first time we've run. Initialize the TPM. */
VBDEBUG("TPM: Not initialized yet\n");
RETURN_ON_FAILURE(factory_initialize_tpm(ctx));
} else if (rv != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Failed to read firmware space: %#x\n", rv);
} else if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "TPM: Failed to read firmware space: %#x\n", rc);
return TPM_E_CORRUPTED_STATE;
}
@@ -706,10 +710,10 @@ uint32_t antirollback_write_space_kernel(struct vb2_context *ctx)
vb2_error_t vb2ex_tpm_clear_owner(struct vb2_context *ctx)
{
uint32_t rv;
uint32_t rc;
printk(BIOS_INFO, "Clearing TPM owner\n");
rv = tpm_clear_and_reenable();
if (rv)
rc = tpm_clear_and_reenable();
if (rc)
return VB2_ERROR_EX_TPM_CLEAR_OWNER;
return VB2_SUCCESS;
}

8
src/security/vboot/tpm_common.c
View File

@@ -10,13 +10,13 @@
uint32_t vboot_setup_tpm(struct vb2_context *ctx)
{
uint32_t result;
uint32_t rc;
result = tpm_setup(ctx->flags & VB2_CONTEXT_S3_RESUME);
if (result == TPM_E_MUST_REBOOT)
rc = tpm_setup(ctx->flags & VB2_CONTEXT_S3_RESUME);
if (rc == TPM_E_MUST_REBOOT)
ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
return result;
return rc;
}
vb2_error_t vboot_extend_pcr(struct vb2_context *ctx, int pcr,

28
src/security/vboot/vboot_logic.c
View File

@@ -127,7 +127,7 @@ static vb2_error_t hash_body(struct vb2_context *ctx,
const size_t hash_digest_sz = sizeof(hash_digest);
size_t block_size = sizeof(block);
size_t offset;
vb2_error_t rv;
vb2_error_t rc;
/* Clear the full digest so that any hash digests less than the
* max have trailing zeros. */
@@ -146,9 +146,9 @@ static vb2_error_t hash_body(struct vb2_context *ctx,
offset = 0;
/* Start the body hash */
rv = vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY);
if (rv)
return rv;
rc = vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY);
if (rc)
return rc;
/* Extend over the body */
while (remaining) {
@@ -161,9 +161,9 @@ static vb2_error_t hash_body(struct vb2_context *ctx,
return VB2_ERROR_UNKNOWN;
load_ts += timestamp_get() - temp_ts;
rv = vb2api_extend_hash(ctx, block, block_size);
if (rv)
return rv;
rc = vb2api_extend_hash(ctx, block, block_size);
if (rc)
return rc;
remaining -= block_size;
offset += block_size;
@@ -173,9 +173,9 @@ static vb2_error_t hash_body(struct vb2_context *ctx,
timestamp_add_now(TS_HASHING_END);
/* Check the result (with RSA signature verification) */
rv = vb2api_check_hash_get_digest(ctx, hash_digest, hash_digest_sz);
if (rv)
return rv;
rc = vb2api_check_hash_get_digest(ctx, hash_digest, hash_digest_sz);
if (rc)
return rc;
timestamp_add_now(TS_HASH_BODY_END);
@@ -210,10 +210,10 @@ static const char *get_boot_mode_string(uint8_t boot_mode)
static void check_boot_mode(struct vb2_context *ctx)
{
uint8_t boot_mode;
int rv;
int rc;
rv = tlcl_cr50_get_boot_mode(&boot_mode);
switch (rv) {
rc = tlcl_cr50_get_boot_mode(&boot_mode);
switch (rc) {
case TPM_E_NO_SUCH_COMMAND:
printk(BIOS_WARNING, "GSC does not support GET_BOOT_MODE.\n");
/* Proceed to legacy boot model. */
@@ -223,7 +223,7 @@ static void check_boot_mode(struct vb2_context *ctx)
default:
printk(BIOS_ERR,
"Communication error in getting GSC boot mode.\n");
vb2api_fail(ctx, VB2_RECOVERY_GSC_BOOT_MODE, rv);
vb2api_fail(ctx, VB2_RECOVERY_GSC_BOOT_MODE, rc);
return;
}

14
src/soc/amd/common/psp_verstage/psp_verstage.c
View File

@@ -208,7 +208,7 @@ static uint32_t save_buffers(void)
*/
static void psp_verstage_s0i3_resume(void)
{
uint32_t rv;
uint32_t rc;
post_code(POSTCODE_VERSTAGE_S0I3_RESUME);
@@ -217,15 +217,15 @@ static void psp_verstage_s0i3_resume(void)
if (!CONFIG(PSP_INIT_TPM_ON_S0I3_RESUME))
return;
rv = tpm_setup(true);
if (rv != TPM_SUCCESS) {
printk(BIOS_ERR, "tpm_setup failed rv:%d\n", rv);
rc = tpm_setup(true);
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "tpm_setup failed rc:%d\n", rc);
reboot_into_recovery(vboot_get_context(), POSTCODE_INIT_TPM_FAILED);
}
rv = tlcl_disable_platform_hierarchy();
if (rv != TPM_SUCCESS) {
printk(BIOS_ERR, "tlcl_disable_platform_hierarchy failed rv:%d\n", rv);
rc = tlcl_disable_platform_hierarchy();
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "tlcl_disable_platform_hierarchy failed rc:%d\n", rc);
reboot_into_recovery(vboot_get_context(), POSTCODE_INIT_TPM_FAILED);
}
}

100
src/vendorcode/eltan/security/mboot/mboot.c
View File

@@ -13,14 +13,14 @@
*/
EFI_TCG2_EVENT_ALGORITHM_BITMAP tpm2_get_active_pcrs(void)
{
int status;
int rc;
TPML_PCR_SELECTION Pcrs;
EFI_TCG2_EVENT_ALGORITHM_BITMAP tpmHashAlgorithmBitmap = 0;
uint32_t activePcrBanks = 0;
uint32_t index;
status = tpm2_get_capability_pcrs(&Pcrs);
if (status != TPM_SUCCESS) {
rc = tpm2_get_capability_pcrs(&Pcrs);
if (rc != TPM_SUCCESS) {
tpmHashAlgorithmBitmap = EFI_TCG2_BOOT_HASH_ALG_SHA1;
activePcrBanks = EFI_TCG2_BOOT_HASH_ALG_SHA1;
} else {
@@ -78,11 +78,11 @@ EFI_TCG2_EVENT_ALGORITHM_BITMAP tpm2_get_active_pcrs(void)
int tpm2_get_capability_pcrs(TPML_PCR_SELECTION *Pcrs)
{
TPMS_CAPABILITY_DATA TpmCap;
int status;
int rc;
int index;
status = tlcl_get_capability(TPM_CAP_PCRS, 0, 1, &TpmCap);
if (status == TPM_SUCCESS) {
rc = tlcl_get_capability(TPM_CAP_PCRS, 0, 1, &TpmCap);
if (rc == TPM_SUCCESS) {
Pcrs->count = TpmCap.data.assignedPCR.count;
printk(BIOS_DEBUG, "Pcrs->count = %d\n", Pcrs->count);
for (index = 0; index < Pcrs->count; index++) {
@@ -97,7 +97,7 @@ int tpm2_get_capability_pcrs(TPML_PCR_SELECTION *Pcrs)
Pcrs->pcrSelections[index].sizeofSelect);
}
}
return status;
return rc;
}
/*
@@ -149,7 +149,7 @@ int mboot_hash_extend_log(uint64_t flags, uint8_t *hashData, uint32_t hashDataLe
void invalidate_pcrs(void)
{
int pcr;
int status;
int rc;
TCG_PCR_EVENT2_HDR tcgEventHdr;
uint8_t invalidate = 1;
@@ -161,12 +161,12 @@ void invalidate_pcrs(void)
tcgEventHdr.eventType = EV_NO_ACTION;
tcgEventHdr.eventSize = (uint32_t) sizeof(invalidate);
status = mboot_hash_extend_log(0, (uint8_t *)&invalidate,
rc = mboot_hash_extend_log(0, (uint8_t *)&invalidate,
tcgEventHdr.eventSize, &tcgEventHdr,
(uint8_t *)"Invalidate PCR");
if (status != TPM_SUCCESS)
if (rc != TPM_SUCCESS)
printk(BIOS_DEBUG, "%s: invalidating pcr %d returned"
" 0x%x\n", __func__, pcr, status);
" 0x%x\n", __func__, pcr, rc);
}
}
@@ -230,7 +230,7 @@ void mboot_print_buffer(uint8_t *buffer, uint32_t bufferSize)
int mb_measure_log_worker(const char *name, uint32_t type, uint32_t pcr,
TCG_EVENTTYPE eventType, const char *event_msg)
{
int status;
int rc;
TCG_PCR_EVENT2_HDR tcgEventHdr;
uint8_t *base;
size_t size;
@@ -250,8 +250,8 @@ int mb_measure_log_worker(const char *name, uint32_t type, uint32_t pcr,
if (event_msg)
tcgEventHdr.eventSize = (uint32_t) strlen(event_msg);
status = mboot_hash_extend_log(0, base, size, &tcgEventHdr, (uint8_t *)event_msg);
return status;
rc = mboot_hash_extend_log(0, base, size, &tcgEventHdr, (uint8_t *)event_msg);
return rc;
}
/*
@@ -273,7 +273,7 @@ int mb_measure_log_worker(const char *name, uint32_t type, uint32_t pcr,
__weak int mb_entry(int wake_from_s3)
{
int status;
int rc;
/* Initialize TPM driver. */
printk(BIOS_DEBUG, "%s: tlcl_lib_init\n", __func__);
@@ -284,16 +284,16 @@ __weak int mb_entry(int wake_from_s3)
if (wake_from_s3) {
printk(BIOS_DEBUG, "%s: tlcl_resume\n", __func__);
status = tlcl_resume();
rc = tlcl_resume();
} else {
printk(BIOS_DEBUG, "%s: tlcl_startup\n", __func__);
status = tlcl_startup();
rc = tlcl_startup();
}
if (status)
printk(BIOS_ERR, "%s: StartUp failed 0x%x!\n", __func__, status);
if (rc)
printk(BIOS_ERR, "%s: StartUp failed 0x%x!\n", __func__, rc);
return status;
return rc;
}
/*
@@ -317,25 +317,25 @@ __weak int mb_entry(int wake_from_s3)
__weak int mb_measure(int wake_from_s3)
{
uint32_t status;
uint32_t rc;
status = mb_entry(wake_from_s3);
if (status == TPM_SUCCESS) {
rc = mb_entry(wake_from_s3);
if (rc == TPM_SUCCESS) {
printk(BIOS_DEBUG, "%s: StartUp, successful!\n", __func__);
status = mb_measure_log_start();
if (status == TPM_SUCCESS) {
rc = mb_measure_log_start();
if (rc == TPM_SUCCESS) {
printk(BIOS_DEBUG, "%s: Measuring, successful!\n", __func__);
} else {
invalidate_pcrs();
printk(BIOS_ERR, "%s: Measuring returned 0x%x unsuccessful! PCRs invalidated.\n",
__func__, status);
__func__, rc);
}
} else {
invalidate_pcrs();
printk(BIOS_ERR, "%s: StartUp returned 0x%x, unsuccessful! PCRs invalidated.\n", __func__,
status);
rc);
}
return status;
return rc;
}
/*
@@ -359,7 +359,7 @@ __weak int mb_measure(int wake_from_s3)
*/
__weak int mb_measure_log_start(void)
{
int status;
int rc;
uint32_t i;
if ((tpm2_get_active_pcrs() & EFI_TCG2_BOOT_HASH_ALG_SHA256) == 0x0) {
@@ -368,32 +368,32 @@ __weak int mb_measure_log_start(void)
return TPM_E_IOERROR;
}
status = mb_crtm();
if (status != TPM_SUCCESS) {
rc = mb_crtm();
if (rc != TPM_SUCCESS) {
printk(BIOS_DEBUG, "%s: Fail! CRTM Version can't be measured."
" ABORTING!!!\n", __func__);
return status;
return rc;
}
printk(BIOS_DEBUG, "%s: Success! CRTM Version measured.\n", __func__);
/* Log the items defined by the mainboard */
for (i = 0; i < ARRAY_SIZE(mb_log_list); i++) {
status = mb_measure_log_worker(
rc = mb_measure_log_worker(
mb_log_list[i].cbfs_name,
mb_log_list[i].cbfs_type, mb_log_list[i].pcr,
mb_log_list[i].eventType,
mb_log_list[i].event_msg);
if (status != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
printk(BIOS_DEBUG, "%s: Fail! %s can't be measured."
"ABORTING!!!\n", __func__,
mb_log_list[i].cbfs_name);
return status;
return rc;
}
printk(BIOS_DEBUG, "%s: Success! %s measured to pcr"
"%d.\n", __func__, mb_log_list[i].cbfs_name,
mb_log_list[i].pcr);
}
return status;
return rc;
}
static const uint8_t crtm_version[] =
@@ -416,7 +416,7 @@ static const uint8_t crtm_version[] =
**/
__weak int mb_crtm(void)
{
int status;
int rc;
TCG_PCR_EVENT2_HDR tcgEventHdr;
uint8_t hash[VB2_SHA256_DIGEST_SIZE];
uint8_t *msgPtr;
@@ -430,18 +430,18 @@ __weak int mb_crtm(void)
printk(BIOS_DEBUG, "%s: EventSize - %u\n", __func__,
tcgEventHdr.eventSize);
status = mboot_hash_extend_log(0, (uint8_t *)crtm_version, tcgEventHdr.eventSize,
rc = mboot_hash_extend_log(0, (uint8_t *)crtm_version, tcgEventHdr.eventSize,
&tcgEventHdr, (uint8_t *)crtm_version);
if (status) {
printk(BIOS_DEBUG, "Measure CRTM Version returned 0x%x\n", status);
return status;
if (rc) {
printk(BIOS_DEBUG, "Measure CRTM Version returned 0x%x\n", rc);
return rc;
}
status = get_intel_me_hash(hash);
if (status) {
printk(BIOS_DEBUG, "get_intel_me_hash returned 0x%x\n", status);
status = TPM_E_IOERROR;
return status;
rc = get_intel_me_hash(hash);
if (rc) {
printk(BIOS_DEBUG, "get_intel_me_hash returned 0x%x\n", rc);
rc = TPM_E_IOERROR;
return rc;
}
/* Add the me hash */
@@ -453,10 +453,10 @@ __weak int mb_crtm(void)
msgPtr = NULL;
tcgEventHdr.eventSize = 0;
status = mboot_hash_extend_log(MBOOT_HASH_PROVIDED, hash, sizeof(hash), &tcgEventHdr,
rc = mboot_hash_extend_log(MBOOT_HASH_PROVIDED, hash, sizeof(hash), &tcgEventHdr,
msgPtr);
if (status)
printk(BIOS_DEBUG, "Add ME hash returned 0x%x\n", status);
if (rc)
printk(BIOS_DEBUG, "Add ME hash returned 0x%x\n", rc);
return status;
return rc;
}

32
src/vendorcode/google/chromeos/cr50_enable_update.c
View File

@@ -25,27 +25,27 @@ void __weak mainboard_prepare_cr50_reset(void) {}
*/
static int cr50_is_reset_needed(void)
{
int ret;
int rc;
uint8_t tpm_mode;
ret = tlcl_cr50_get_tpm_mode(&tpm_mode);
rc = tlcl_cr50_get_tpm_mode(&tpm_mode);
if (ret == TPM_E_NO_SUCH_COMMAND) {
if (rc == TPM_E_NO_SUCH_COMMAND) {
printk(BIOS_INFO,
"Cr50 does not support TPM mode command\n");
/* Older Cr50 firmware, assume no Cr50 reset is required */
return 0;
}
if (ret == TPM_E_MUST_REBOOT) {
if (rc == TPM_E_MUST_REBOOT) {
/*
* Cr50 indicated a reboot is required to restore TPM
* functionality.
*/
return 1;
} else if (ret != TPM_SUCCESS) {
} else if (rc != TPM_SUCCESS) {
/* TPM command failed, continue booting. */
printk(BIOS_ERR, "Attempt to get CR50 TPM mode failed: %x\n", ret);
printk(BIOS_ERR, "Attempt to get CR50 TPM mode failed: %x\n", rc);
return 0;
}
@@ -70,7 +70,7 @@ static int cr50_is_reset_needed(void)
static void enable_update(void *unused)
{
int ret;
int rc;
int cr50_reset_reqd = 0;
uint8_t num_restored_headers;
@@ -82,23 +82,23 @@ static void enable_update(void *unused)
if (vboot_get_context()->flags & VB2_CONTEXT_FORCE_RECOVERY_MODE)
return;
ret = tlcl_lib_init();
rc = tlcl_lib_init();
if (ret != VB2_SUCCESS) {
if (rc != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed for CR50 update: %x\n",
ret);
rc);
return;
}
timestamp_add_now(TS_TPM_ENABLE_UPDATE_START);
/* Reboot in 1000 ms if necessary. */
ret = tlcl_cr50_enable_update(CR50_RESET_DELAY_MS,
rc = tlcl_cr50_enable_update(CR50_RESET_DELAY_MS,
&num_restored_headers);
if (ret != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
printk(BIOS_ERR, "Attempt to enable CR50 update failed: %x\n",
ret);
rc);
return;
}
@@ -142,16 +142,16 @@ static void enable_update(void *unused)
* the mainboard specific code runs.
*/
if (cr50_reset_reqd) {
ret = tlcl_cr50_immediate_reset(CR50_RESET_DELAY_MS);
rc = tlcl_cr50_immediate_reset(CR50_RESET_DELAY_MS);
if (ret != TPM_SUCCESS) {
if (rc != TPM_SUCCESS) {
/*
* Reset request failed due to TPM error, continue
* booting but the current boot will likely end up at
* the recovery screen.
*/
printk(BIOS_ERR, "Attempt to reset CR50 failed: %x\n",
ret);
rc);
return;
}
}

8
src/vendorcode/google/chromeos/cse_board_reset.c
View File

@@ -13,7 +13,7 @@
void cse_board_reset(void)
{
int ret;
int rc;
struct cr50_firmware_version version;
if (CONFIG(CSE_RESET_CLEAR_EC_AP_IDLE_FLAG))
@@ -21,9 +21,9 @@ void cse_board_reset(void)
if (CONFIG(TPM2) && CONFIG(TPM_GOOGLE_CR50)) {
/* Initialize TPM and get the cr50 firmware version. */
ret = tlcl_lib_init();
if (ret != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", ret);
rc = tlcl_lib_init();
if (rc != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: 0x%x\n", rc);
return;
}

14
src/vendorcode/google/chromeos/tpm2.c
View File

@@ -7,7 +7,7 @@
static void disable_platform_hierarchy(void *unused)
{
int ret;
int rc;
if (!CONFIG(TPM2))
return;
@@ -15,17 +15,17 @@ static void disable_platform_hierarchy(void *unused)
if (!CONFIG(RESUME_PATH_SAME_AS_BOOT))
return;
ret = tlcl_lib_init();
rc = tlcl_lib_init();
if (ret != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: %x\n", ret);
if (rc != VB2_SUCCESS) {
printk(BIOS_ERR, "tlcl_lib_init() failed: %x\n", rc);
return;
}
ret = tlcl_disable_platform_hierarchy();
if (ret != TPM_SUCCESS)
rc = tlcl_disable_platform_hierarchy();
if (rc != TPM_SUCCESS)
printk(BIOS_ERR, "Platform hierarchy disablement failed: %x\n",
ret);
rc);
}
BOOT_STATE_INIT_ENTRY(BS_OS_RESUME, BS_ON_ENTRY, disable_platform_hierarchy,