509 lines
14 KiB
C
509 lines
14 KiB
C
/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*
|
|
* Tests for vboot_api_kernel, part 3 - software sync
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "2sysincludes.h"
|
|
#include "2common.h"
|
|
#include "2misc.h"
|
|
#include "2nvstorage.h"
|
|
#include "ec_sync.h"
|
|
#include "host_common.h"
|
|
#include "load_kernel_fw.h"
|
|
#include "secdata_tpm.h"
|
|
#include "test_common.h"
|
|
#include "vboot_audio.h"
|
|
#include "vboot_common.h"
|
|
#include "vboot_display.h"
|
|
#include "vboot_kernel.h"
|
|
#include "vboot_struct.h"
|
|
|
|
/* Mock data */
|
|
static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
|
|
static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
|
|
|
|
static int mock_in_rw;
|
|
static vb2_error_t in_rw_retval;
|
|
static int protect_retval;
|
|
static int ec_ro_protected;
|
|
static int ec_rw_protected;
|
|
static int run_retval;
|
|
static int ec_run_image;
|
|
static int update_retval;
|
|
static int ec_ro_updated;
|
|
static int ec_rw_updated;
|
|
static int get_expected_retval;
|
|
static int shutdown_request_calls_left;
|
|
|
|
static uint8_t mock_ec_ro_hash[32];
|
|
static uint8_t mock_ec_rw_hash[32];
|
|
static int mock_ec_ro_hash_size;
|
|
static int mock_ec_rw_hash_size;
|
|
static uint8_t want_ec_hash[32];
|
|
static uint8_t update_hash;
|
|
static int want_ec_hash_size;
|
|
static struct vb2_context ctx;
|
|
static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
|
|
static struct vb2_shared_data *sd;
|
|
static struct vb2_gbb_header gbb;
|
|
|
|
static uint32_t screens_displayed[8];
|
|
static uint32_t screens_count = 0;
|
|
|
|
static vb2_error_t ec_aux_fw_retval;
|
|
static int ec_aux_fw_update_req;
|
|
static VbAuxFwUpdateSeverity_t ec_aux_fw_mock_severity;
|
|
static VbAuxFwUpdateSeverity_t ec_aux_fw_update_severity;
|
|
static int ec_aux_fw_protected;
|
|
|
|
/* Reset mock data (for use before each test) */
|
|
static void ResetMocks(void)
|
|
{
|
|
memset(&ctx, 0, sizeof(ctx));
|
|
ctx.workbuf = workbuf;
|
|
ctx.workbuf_size = sizeof(workbuf);
|
|
ctx.flags = VB2_CONTEXT_EC_SYNC_SUPPORTED;
|
|
vb2_init_context(&ctx);
|
|
vb2_nv_init(&ctx);
|
|
|
|
sd = vb2_get_sd(&ctx);
|
|
sd->vbsd = shared;
|
|
sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
|
|
|
|
memset(&gbb, 0, sizeof(gbb));
|
|
|
|
memset(&shared_data, 0, sizeof(shared_data));
|
|
VbSharedDataInit(shared, sizeof(shared_data));
|
|
|
|
mock_in_rw = 0;
|
|
ec_ro_protected = 0;
|
|
ec_rw_protected = 0;
|
|
ec_run_image = 0; /* 0 = RO, 1 = RW */
|
|
ec_ro_updated = 0;
|
|
ec_rw_updated = 0;
|
|
in_rw_retval = VB2_SUCCESS;
|
|
protect_retval = VB2_SUCCESS;
|
|
update_retval = VB2_SUCCESS;
|
|
run_retval = VB2_SUCCESS;
|
|
get_expected_retval = VB2_SUCCESS;
|
|
shutdown_request_calls_left = -1;
|
|
|
|
memset(mock_ec_ro_hash, 0, sizeof(mock_ec_ro_hash));
|
|
mock_ec_ro_hash[0] = 42;
|
|
mock_ec_ro_hash_size = sizeof(mock_ec_ro_hash);
|
|
|
|
memset(mock_ec_rw_hash, 0, sizeof(mock_ec_rw_hash));
|
|
mock_ec_rw_hash[0] = 42;
|
|
mock_ec_rw_hash_size = sizeof(mock_ec_rw_hash);
|
|
|
|
memset(want_ec_hash, 0, sizeof(want_ec_hash));
|
|
want_ec_hash[0] = 42;
|
|
want_ec_hash_size = sizeof(want_ec_hash);
|
|
|
|
update_hash = 42;
|
|
|
|
// TODO: ensure these are actually needed
|
|
|
|
memset(screens_displayed, 0, sizeof(screens_displayed));
|
|
screens_count = 0;
|
|
|
|
ec_aux_fw_retval = VB2_SUCCESS;
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_NO_UPDATE;
|
|
ec_aux_fw_update_severity = VB_AUX_FW_NO_UPDATE;
|
|
ec_aux_fw_update_req = 0;
|
|
ec_aux_fw_protected = 0;
|
|
}
|
|
|
|
/* Mock functions */
|
|
struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
|
|
{
|
|
return &gbb;
|
|
}
|
|
|
|
uint32_t VbExIsShutdownRequested(void)
|
|
{
|
|
if (shutdown_request_calls_left == 0)
|
|
return 1;
|
|
else if (shutdown_request_calls_left > 0)
|
|
shutdown_request_calls_left--;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VbExTrustEC(int devidx)
|
|
{
|
|
return !mock_in_rw;
|
|
}
|
|
|
|
vb2_error_t VbExEcRunningRW(int devidx, int *in_rw)
|
|
{
|
|
*in_rw = mock_in_rw;
|
|
return in_rw_retval;
|
|
}
|
|
|
|
vb2_error_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select)
|
|
{
|
|
if (select == VB_SELECT_FIRMWARE_READONLY)
|
|
ec_ro_protected = 1;
|
|
else
|
|
ec_rw_protected = 1;
|
|
return protect_retval;
|
|
}
|
|
|
|
vb2_error_t VbExEcDisableJump(int devidx)
|
|
{
|
|
return run_retval;
|
|
}
|
|
|
|
vb2_error_t VbExEcJumpToRW(int devidx)
|
|
{
|
|
ec_run_image = 1;
|
|
mock_in_rw = 1;
|
|
return run_retval;
|
|
}
|
|
|
|
vb2_error_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
|
|
const uint8_t **hash, int *hash_size)
|
|
{
|
|
*hash = select == VB_SELECT_FIRMWARE_READONLY ?
|
|
mock_ec_ro_hash : mock_ec_rw_hash;
|
|
*hash_size = select == VB_SELECT_FIRMWARE_READONLY ?
|
|
mock_ec_ro_hash_size : mock_ec_rw_hash_size;
|
|
return *hash_size ? VB2_SUCCESS : VB2_ERROR_MOCK;
|
|
}
|
|
|
|
vb2_error_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
|
|
const uint8_t **image, int *image_size)
|
|
{
|
|
static uint8_t fake_image[64] = {5, 6, 7, 8};
|
|
*image = fake_image;
|
|
*image_size = sizeof(fake_image);
|
|
return get_expected_retval;
|
|
}
|
|
|
|
vb2_error_t VbExEcGetExpectedImageHash(int devidx,
|
|
enum VbSelectFirmware_t select,
|
|
const uint8_t **hash, int *hash_size)
|
|
{
|
|
*hash = want_ec_hash;
|
|
*hash_size = want_ec_hash_size;
|
|
|
|
return want_ec_hash_size ? VB2_SUCCESS : VB2_ERROR_MOCK;
|
|
}
|
|
|
|
vb2_error_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
|
|
const uint8_t *image, int image_size)
|
|
{
|
|
if (select == VB_SELECT_FIRMWARE_READONLY) {
|
|
ec_ro_updated = 1;
|
|
mock_ec_ro_hash[0] = update_hash;
|
|
} else {
|
|
ec_rw_updated = 1;
|
|
mock_ec_rw_hash[0] = update_hash;
|
|
}
|
|
return update_retval;
|
|
}
|
|
|
|
vb2_error_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
|
|
const VbScreenData *data)
|
|
{
|
|
if (screens_count < ARRAY_SIZE(screens_displayed))
|
|
screens_displayed[screens_count++] = screen;
|
|
|
|
return VB2_SUCCESS;
|
|
}
|
|
|
|
vb2_error_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity)
|
|
{
|
|
*severity = ec_aux_fw_mock_severity;
|
|
ec_aux_fw_update_severity = ec_aux_fw_mock_severity;
|
|
return VB2_SUCCESS;
|
|
}
|
|
|
|
vb2_error_t VbExUpdateAuxFw()
|
|
{
|
|
if (ec_aux_fw_update_severity != VB_AUX_FW_NO_DEVICE &&
|
|
ec_aux_fw_update_severity != VB_AUX_FW_NO_UPDATE)
|
|
ec_aux_fw_update_req = 1;
|
|
return ec_aux_fw_retval;
|
|
}
|
|
|
|
vb2_error_t VbExEcVbootDone(int in_recovery)
|
|
{
|
|
ec_aux_fw_protected = ec_aux_fw_update_severity != VB_AUX_FW_NO_DEVICE;
|
|
return ec_aux_fw_retval;
|
|
}
|
|
|
|
static void test_ssync(vb2_error_t retval, int recovery_reason,
|
|
const char *desc)
|
|
{
|
|
TEST_EQ(ec_sync_all(&ctx), retval, desc);
|
|
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
|
|
recovery_reason, " recovery reason");
|
|
}
|
|
|
|
/* Tests */
|
|
|
|
static void VbSoftwareSyncTest(void)
|
|
{
|
|
/* AP-RO cases */
|
|
ResetMocks();
|
|
in_rw_retval = VB2_ERROR_MOCK;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image");
|
|
|
|
/* Calculate hashes */
|
|
ResetMocks();
|
|
mock_ec_rw_hash_size = 0;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_HASH_FAILED, "Bad EC hash");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash_size = 16;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_HASH_SIZE, "Bad EC hash size");
|
|
|
|
ResetMocks();
|
|
want_ec_hash_size = 0;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash");
|
|
|
|
ResetMocks();
|
|
want_ec_hash_size = 16;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_HASH_SIZE,
|
|
"Hash size mismatch");
|
|
|
|
ResetMocks();
|
|
want_ec_hash_size = 4;
|
|
mock_ec_rw_hash_size = 4;
|
|
test_ssync(0, 0, "Custom hash size");
|
|
|
|
/* Updates required */
|
|
ResetMocks();
|
|
mock_in_rw = 1;
|
|
mock_ec_rw_hash[0]++;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
0, "Pending update needs reboot");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
vb2_nv_set(&ctx, VB2_NV_TRY_RO_SYNC, 1);
|
|
test_ssync(0, 0, "Update rw without reboot");
|
|
TEST_EQ(ec_rw_protected, 1, " ec rw protected");
|
|
TEST_EQ(ec_run_image, 1, " ec run image");
|
|
TEST_EQ(ec_rw_updated, 1, " ec rw updated");
|
|
TEST_EQ(ec_ro_protected, 1, " ec ro protected");
|
|
TEST_EQ(ec_ro_updated, 0, " ec ro updated");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
mock_ec_ro_hash[0]++;
|
|
vb2_nv_set(&ctx, VB2_NV_TRY_RO_SYNC, 1);
|
|
test_ssync(0, 0, "Update rw and ro images without reboot");
|
|
TEST_EQ(ec_rw_protected, 1, " ec rw protected");
|
|
TEST_EQ(ec_run_image, 1, " ec run image");
|
|
TEST_EQ(ec_rw_updated, 1, " ec rw updated");
|
|
TEST_EQ(ec_ro_protected, 1, " ec ro protected");
|
|
TEST_EQ(ec_ro_updated, 1, " ec ro updated");
|
|
|
|
ResetMocks();
|
|
vb2_nv_set(&ctx, VB2_NV_TRY_RO_SYNC, 1);
|
|
mock_ec_ro_hash[0]++;
|
|
vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
|
|
test_ssync(0, 0, "rw update not needed");
|
|
TEST_EQ(ec_rw_protected, 1, " ec rw protected");
|
|
TEST_EQ(ec_run_image, 1, " ec run image");
|
|
TEST_EQ(ec_rw_updated, 0, " ec rw not updated");
|
|
TEST_EQ(ec_ro_protected, 1, " ec ro protected");
|
|
TEST_EQ(ec_ro_updated, 1, " ec ro updated");
|
|
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 1,
|
|
" DISPLAY_REQUEST left untouched");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
mock_ec_ro_hash[0]++;
|
|
test_ssync(0, 0, "ro update not requested");
|
|
TEST_EQ(ec_rw_protected, 1, " ec rw protected");
|
|
TEST_EQ(ec_run_image, 1, " ec run image");
|
|
TEST_EQ(ec_rw_updated, 1, " ec rw updated");
|
|
TEST_EQ(ec_ro_protected, 1, " ec ro protected");
|
|
TEST_EQ(ec_ro_updated, 0, " ec ro updated");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
update_hash++;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_UPDATE, "updated hash mismatch");
|
|
TEST_EQ(ec_rw_protected, 0, " ec rw protected");
|
|
TEST_EQ(ec_run_image, 0, " ec run image");
|
|
TEST_EQ(ec_rw_updated, 1, " ec rw updated");
|
|
TEST_EQ(ec_ro_protected, 0, " ec ro protected");
|
|
TEST_EQ(ec_ro_updated, 0, " ec ro updated");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
update_retval = VBERROR_EC_REBOOT_TO_RO_REQUIRED;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
0, "Reboot after rw update");
|
|
TEST_EQ(ec_rw_updated, 1, " ec rw updated");
|
|
TEST_EQ(ec_ro_updated, 0, " ec rw updated");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
update_retval = VB2_ERROR_MOCK;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_UPDATE, "Update failed");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
|
|
test_ssync(0, 0, "Slow update");
|
|
TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT, " wait screen");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
|
|
sd->flags &= ~VB2_SD_FLAG_DISPLAY_AVAILABLE;
|
|
test_ssync(VBERROR_REBOOT_REQUIRED, 0,
|
|
"Slow update - reboot for display");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
|
|
vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
|
|
test_ssync(VB2_SUCCESS, 0,
|
|
"Slow update with display request");
|
|
TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT, " wait screen");
|
|
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 1,
|
|
" DISPLAY_REQUEST left untouched");
|
|
|
|
ResetMocks();
|
|
mock_ec_rw_hash[0]++;
|
|
ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
|
|
vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 0);
|
|
test_ssync(VB2_SUCCESS, 0,
|
|
"Slow update without display request (no reboot needed)");
|
|
TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT, " wait screen");
|
|
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 0,
|
|
" DISPLAY_REQUEST left untouched");
|
|
|
|
/* RW cases, no update */
|
|
ResetMocks();
|
|
mock_in_rw = 1;
|
|
test_ssync(0, 0, "AP-RW, EC-RW");
|
|
|
|
ResetMocks();
|
|
test_ssync(0, 0, "AP-RW, EC-RO -> EC-RW");
|
|
TEST_EQ(ec_rw_protected, 1, " ec rw protected");
|
|
TEST_EQ(ec_run_image, 1, " ec run image");
|
|
TEST_EQ(ec_rw_updated, 0, " ec rw updated");
|
|
TEST_EQ(ec_ro_protected, 1, " ec ro protected");
|
|
TEST_EQ(ec_ro_updated, 0, " ec ro updated");
|
|
|
|
ResetMocks();
|
|
run_retval = VB2_ERROR_MOCK;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
VB2_RECOVERY_EC_JUMP_RW, "Jump to RW fail");
|
|
|
|
ResetMocks();
|
|
run_retval = VBERROR_EC_REBOOT_TO_RO_REQUIRED;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
|
|
0, "Jump to RW fail because locked");
|
|
|
|
ResetMocks();
|
|
protect_retval = VB2_ERROR_MOCK;
|
|
test_ssync(VB2_ERROR_MOCK,
|
|
VB2_RECOVERY_EC_PROTECT, "Protect error");
|
|
|
|
/* No longer check for shutdown requested */
|
|
ResetMocks();
|
|
shutdown_request_calls_left = 0;
|
|
test_ssync(0, 0,
|
|
"AP-RW, EC-RO -> EC-RW shutdown requested");
|
|
|
|
ResetMocks();
|
|
mock_in_rw = 1;
|
|
shutdown_request_calls_left = 0;
|
|
test_ssync(0, 0, "AP-RW shutdown requested");
|
|
|
|
ResetMocks();
|
|
gbb.flags |= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_FAST_UPDATE;
|
|
test_ssync(VB2_SUCCESS, 0,
|
|
"VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC"
|
|
" disables auxiliary FW update request");
|
|
TEST_EQ(ec_aux_fw_update_req, 0, " aux fw update disabled");
|
|
TEST_EQ(ec_aux_fw_protected, 1, " aux fw protected");
|
|
|
|
ResetMocks();
|
|
gbb.flags |= VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC;
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_FAST_UPDATE;
|
|
test_ssync(VB2_SUCCESS, 0,
|
|
"VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC"
|
|
" disables auxiliary FW update request");
|
|
TEST_EQ(ec_aux_fw_update_req, 0, " aux fw update disabled");
|
|
TEST_EQ(ec_aux_fw_protected, 1, " aux fw protected");
|
|
|
|
ResetMocks();
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_NO_DEVICE;
|
|
test_ssync(VB2_SUCCESS, 0,
|
|
"No auxiliary FW update needed");
|
|
TEST_EQ(screens_count, 0,
|
|
" wait screen skipped");
|
|
TEST_EQ(ec_aux_fw_update_req, 0, " no aux fw update requested");
|
|
TEST_EQ(ec_aux_fw_protected, 0, " no aux fw protected");
|
|
|
|
ResetMocks();
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_NO_UPDATE;
|
|
test_ssync(VB2_SUCCESS, 0,
|
|
"No auxiliary FW update needed");
|
|
TEST_EQ(screens_count, 0,
|
|
" wait screen skipped");
|
|
TEST_EQ(ec_aux_fw_update_req, 0, " no aux fw update requested");
|
|
TEST_EQ(ec_aux_fw_protected, 1, " aux fw protected");
|
|
|
|
ResetMocks();
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_FAST_UPDATE;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, 0,
|
|
"Fast auxiliary FW update needed");
|
|
TEST_EQ(screens_count, 0,
|
|
" wait screen skipped");
|
|
TEST_EQ(ec_aux_fw_update_req, 1, " aux fw update requested");
|
|
TEST_EQ(ec_aux_fw_protected, 0, " aux fw protected");
|
|
|
|
ResetMocks();
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_SLOW_UPDATE;
|
|
sd->flags &= ~VB2_SD_FLAG_DISPLAY_AVAILABLE;
|
|
test_ssync(VBERROR_REBOOT_REQUIRED, 0,
|
|
"Slow auxiliary FW update needed - reboot for display");
|
|
|
|
ResetMocks();
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_SLOW_UPDATE;
|
|
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, 0,
|
|
"Slow auxiliary FW update needed");
|
|
TEST_EQ(ec_aux_fw_update_req, 1, " aux fw update requested");
|
|
TEST_EQ(ec_aux_fw_protected, 0, " aux fw protected");
|
|
TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT,
|
|
" wait screen forced");
|
|
|
|
ResetMocks();
|
|
ec_aux_fw_mock_severity = VB_AUX_FW_FAST_UPDATE;
|
|
ec_aux_fw_retval = VB2_ERROR_UNKNOWN;
|
|
test_ssync(VB2_ERROR_UNKNOWN, VB2_RECOVERY_AUX_FW_UPDATE,
|
|
"Error updating AUX firmware");
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
VbSoftwareSyncTest();
|
|
|
|
return gTestSuccess ? 0 : 255;
|
|
}
|