diff options
Diffstat (limited to 'firmware/lib')
| -rw-r--r-- | firmware/lib/include/load_kernel_fw.h | 6 | ||||
| -rw-r--r-- | firmware/lib/include/vboot_display.h | 2 | ||||
| -rw-r--r-- | firmware/lib/vboot_api_kernel.c | 131 | ||||
| -rw-r--r-- | firmware/lib/vboot_display.c | 143 | ||||
| -rw-r--r-- | firmware/lib/vboot_kernel.c | 8 | ||||
| -rw-r--r-- | firmware/lib/vboot_nvstorage.c | 496 | ||||
| -rw-r--r-- | firmware/lib/vboot_ui.c | 15 | ||||
| -rw-r--r-- | firmware/lib/vboot_ui_menu.c | 19 |
8 files changed, 137 insertions, 683 deletions
diff --git a/firmware/lib/include/load_kernel_fw.h b/firmware/lib/include/load_kernel_fw.h index ca49b3c6..08e55787 100644 --- a/firmware/lib/include/load_kernel_fw.h +++ b/firmware/lib/include/load_kernel_fw.h @@ -10,7 +10,6 @@ #define VBOOT_REFERENCE_LOAD_KERNEL_FW_H_ #include "vboot_api.h" -#include "vboot_nvstorage.h" struct vb2_context; @@ -38,11 +37,6 @@ typedef struct LoadKernelParams { uint64_t kernel_buffer_size; /* Boot flags */ uint64_t boot_flags; - /* - * Context for NV storage. Caller is responsible for calling - * VbNvSetup() and VbNvTeardown() on the context. - */ - VbNvContext *nv_context; /* Firmware management parameters; may be NULL if not present. */ const struct RollbackSpaceFwmp *fwmp; diff --git a/firmware/lib/include/vboot_display.h b/firmware/lib/include/vboot_display.h index 2f237533..fbb04e13 100644 --- a/firmware/lib/include/vboot_display.h +++ b/firmware/lib/include/vboot_display.h @@ -9,8 +9,6 @@ #define VBOOT_REFERENCE_VBOOT_DISPLAY_H_ #include "bmpblk_font.h" -#include "vboot_api.h" -#include "vboot_nvstorage.h" struct vb2_context; diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c index 1879b845..26d32d55 100644 --- a/firmware/lib/vboot_api_kernel.c +++ b/firmware/lib/vboot_api_kernel.c @@ -23,10 +23,8 @@ #include "vboot_api.h" #include "vboot_common.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" /* Global variables */ -static VbNvContext vnc; static struct RollbackSpaceFwmp fwmp; static LoadKernelParams lkp; static struct vb2_context ctx; @@ -57,29 +55,14 @@ static void VbSetRecoveryRequest(struct vb2_context *ctx, vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, recovery_request); } -static void VbNvLoad(void) -{ - VbExNvStorageRead(vnc.raw); - VbNvSetup(&vnc); -} - -static void VbNvCommit(void) -{ - VbNvTeardown(&vnc); - if (vnc.raw_changed) - VbExNvStorageWrite(vnc.raw); -} - void vb2_nv_commit(struct vb2_context *ctx) { - /* Copy nvdata back to old vboot1 nv context if needed */ - if (ctx->flags & VB2_CONTEXT_NVDATA_CHANGED) { - memcpy(vnc.raw, ctx->nvdata, VB2_NVDATA_SIZE); - vnc.raw_changed = 1; - ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED; - } + /* Exit if nothing has changed */ + if (!(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED)) + return; - VbNvCommit(); + ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED; + VbExNvStorageWrite(ctx->nvdata); } uint32_t vb2_get_fwmp_flags(void) @@ -112,7 +95,6 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams, (unsigned)get_info_flags); lkp.fwmp = &fwmp; - lkp.nv_context = &vnc; lkp.disk_handle = NULL; /* Find disks */ @@ -122,7 +104,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams, VB2_DEBUG("VbTryLoadKernel() found %d disks\n", (int)disk_count); if (0 == disk_count) { - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_NO_DISK); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_NO_DISK); return VBERROR_NO_DISK_FOUND; } @@ -171,7 +153,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams, /* If we didn't find any good kernels, don't return a disk handle. */ if (VBERROR_SUCCESS != retval) { - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_NO_KERNEL); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_NO_KERNEL); lkp.disk_handle = NULL; } @@ -188,7 +170,8 @@ VbError_t VbBootNormal(struct vb2_context *ctx, VbCommonParams *cparams) { VbSharedDataHeader *shared = (VbSharedDataHeader *)cparams->shared_data_blob; - uint32_t max_rollforward; + uint32_t max_rollforward = vb2_nv_get(ctx, + VB2_NV_KERNEL_MAX_ROLLFORWARD); /* Boot from fixed disk only */ VB2_DEBUG("Entering\n"); @@ -219,35 +202,32 @@ VbError_t VbBootNormal(struct vb2_context *ctx, VbCommonParams *cparams) */ if (rv == VBERROR_INVALID_KERNEL_FOUND) { VB2_DEBUG("Trying FW B; only found invalid kernels.\n"); - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_NOT_REQUESTED); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_NOT_REQUESTED); } return rv; } - /* Limit kernel version rollforward if needed */ - if (0 == VbNvGet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, &max_rollforward)) { - /* - * Can't limit kernel version to less than the version - * currently in the TPM. That is, we're limiting rollforward, - * not allowing rollback. - */ - if (max_rollforward < shared->kernel_version_tpm_start) - max_rollforward = shared->kernel_version_tpm_start; + /* + * Limit kernel version rollforward if needed. Can't limit kernel + * version to less than the version currently in the TPM. That is, + * we're limiting rollforward, not allowing rollback. + */ + if (max_rollforward < shared->kernel_version_tpm_start) + max_rollforward = shared->kernel_version_tpm_start; - if (shared->kernel_version_tpm > max_rollforward) { - VB2_DEBUG("Limiting TPM kernel version roll-forward " - "to 0x%x < 0x%x\n", - max_rollforward, shared->kernel_version_tpm); + if (shared->kernel_version_tpm > max_rollforward) { + VB2_DEBUG("Limiting TPM kernel version roll-forward " + "to 0x%x < 0x%x\n", + max_rollforward, shared->kernel_version_tpm); - shared->kernel_version_tpm = max_rollforward; - } + shared->kernel_version_tpm = max_rollforward; } if ((shared->kernel_version_tpm > shared->kernel_version_tpm_start) && RollbackKernelWrite(shared->kernel_version_tpm)) { VB2_DEBUG("Error writing kernel versions to TPM.\n"); - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_TPM_W_ERROR); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_TPM_W_ERROR); return VBERROR_TPM_WRITE_KERNEL; } @@ -285,8 +265,8 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, */ memset(&ctx, 0, sizeof(ctx)); - VbNvLoad(); - memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE); + VbExNvStorageRead(ctx.nvdata); + vb2_nv_init(&ctx); if (shared->recovery_reason) ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; @@ -325,7 +305,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, * If we're in recovery mode just to do memory retraining, all we * need to do is reboot. */ - if (shared->recovery_reason == VBNV_RECOVERY_TRAIN_AND_REBOOT) { + if (shared->recovery_reason == VB2_RECOVERY_TRAIN_AND_REBOOT) { VB2_DEBUG("Reboot after retraining in recovery.\n"); return VBERROR_REBOOT_REQUIRED; } @@ -355,7 +335,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, VB2_DEBUG("Unable to get kernel versions from TPM\n"); if (!shared->recovery_reason) { VbSetRecoveryRequest(&ctx, - VBNV_RECOVERY_RW_TPM_R_ERROR); + VB2_RECOVERY_RW_TPM_R_ERROR); return VBERROR_TPM_READ_KERNEL; } } @@ -369,7 +349,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, VB2_DEBUG("Unable to get FWMP from TPM\n"); if (!shared->recovery_reason) { VbSetRecoveryRequest(&ctx, - VBNV_RECOVERY_RW_TPM_R_ERROR); + VB2_RECOVERY_RW_TPM_R_ERROR); return VBERROR_TPM_READ_FWMP; } } @@ -398,7 +378,7 @@ static VbError_t vb2_kernel_phase4(VbCommonParams *cparams, if (!shared->recovery_reason && RollbackKernelLock(shared->recovery_reason)) { VB2_DEBUG("Error locking kernel versions.\n"); - VbSetRecoveryRequest(&ctx, VBNV_RECOVERY_RW_TPM_L_ERROR); + VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_TPM_L_ERROR); return VBERROR_TPM_LOCK_KERNEL; } @@ -484,7 +464,6 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, void *boot_image, size_t image_size) { - VbError_t retval; VbPublicKey* kernel_subkey = NULL; uint8_t *kbuf; VbKeyBlockHeader *key_block; @@ -495,31 +474,19 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, int hash_only = 0; int dev_switch; uint32_t allow_fastboot_full_cap = 0; - uint8_t *workbuf = NULL; struct vb2_workbuf wb; - if ((boot_image == NULL) || (image_size == 0)) - return VBERROR_INVALID_PARAMETER; + VbError_t retval = vb2_kernel_setup(cparams, kparams); + if (retval) + goto fail; - /* Clear output params in case we fail. */ - kparams->disk_handle = NULL; - kparams->partition_number = 0; - kparams->bootloader_address = 0; - kparams->bootloader_size = 0; - kparams->flags = 0; - memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid)); + if ((boot_image == NULL) || (image_size == 0)) { + retval = VBERROR_INVALID_PARAMETER; + goto fail; + } kbuf = boot_image; - /* Read GBB Header */ - cparams->bmp = NULL; - cparams->gbb = malloc(sizeof(*cparams->gbb)); - retval = VbGbbReadHeader_static(cparams, cparams->gbb); - if (VBERROR_SUCCESS != retval) { - VB2_DEBUG("Gbb read header failed.\n"); - return retval; - } - /* * We don't care verifying the image if: * 1. dev-mode switch is on and @@ -529,10 +496,8 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, * Check only the integrity of the image. */ dev_switch = shared->flags & VBSD_BOOT_DEV_SWITCH_ON; - - VbNvLoad(); - VbNvGet(&vnc, VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, - &allow_fastboot_full_cap); + allow_fastboot_full_cap = + vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP); if (0 == allow_fastboot_full_cap) { allow_fastboot_full_cap = !!(cparams->gbb->flags & @@ -547,7 +512,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, retval = VbGbbReadRecoveryKey(cparams, &kernel_subkey); if (VBERROR_SUCCESS != retval) { VB2_DEBUG("Gbb Read Recovery key failed.\n"); - return retval; + goto fail; } } @@ -555,10 +520,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, retval = VBERROR_INVALID_KERNEL_FOUND; /* Allocate work buffer */ - workbuf = (uint8_t *)malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE); - if (!workbuf) - goto fail; - vb2_workbuf_init(&wb, workbuf, VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE); + vb2_workbuf_from_ctx(&ctx, &wb); /* Verify the key block. */ key_block = (VbKeyBlockHeader *)kbuf; @@ -647,11 +609,9 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, retval = VBERROR_SUCCESS; fail: - VbApiKernelFree(cparams); + vb2_kernel_cleanup(&ctx, cparams); if (NULL != kernel_subkey) free(kernel_subkey); - if (NULL != workbuf) - free(workbuf); return retval; } @@ -667,12 +627,13 @@ VbError_t VbUnlockDevice(void) VbError_t VbLockDevice(void) { - VbNvLoad(); - VB2_DEBUG("Storing request to leave dev-mode.\n"); - VbNvSet(&vnc, VBNV_DISABLE_DEV_REQUEST, 1); - VbNvCommit(); + memset(&ctx, 0, sizeof(ctx)); + VbExNvStorageRead(ctx.nvdata); + vb2_nv_init(&ctx); + vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1); + vb2_nv_commit(&ctx); VB2_DEBUG("Mode change will take effect on next reboot.\n"); diff --git a/firmware/lib/vboot_display.c b/firmware/lib/vboot_display.c index 24ac0725..7bf341e1 100644 --- a/firmware/lib/vboot_display.c +++ b/firmware/lib/vboot_display.c @@ -19,7 +19,6 @@ #include "vboot_api.h" #include "vboot_common.h" #include "vboot_display.h" -#include "vboot_nvstorage.h" static uint32_t disp_current_screen = VB_SCREEN_BLANK; static uint32_t disp_current_index = 0; @@ -442,154 +441,154 @@ static void FillInSha1Sum(char *outbuf, VbPublicKey *key) const char *RecoveryReasonString(uint8_t code) { switch(code) { - case VBNV_RECOVERY_NOT_REQUESTED: + case VB2_RECOVERY_NOT_REQUESTED: return "Recovery not requested"; - case VBNV_RECOVERY_LEGACY: + case VB2_RECOVERY_LEGACY: return "Recovery requested from legacy utility"; - case VBNV_RECOVERY_RO_MANUAL: + case VB2_RECOVERY_RO_MANUAL: return "recovery button pressed"; - case VBNV_RECOVERY_RO_INVALID_RW: + case VB2_RECOVERY_RO_INVALID_RW: return "RW firmware failed signature check"; - case VBNV_RECOVERY_RO_S3_RESUME: + case VB2_RECOVERY_RO_S3_RESUME: return "S3 resume failed"; - case VBNV_RECOVERY_DEP_RO_TPM_ERROR: + case VB2_RECOVERY_DEP_RO_TPM_ERROR: return "TPM error in read-only firmware"; - case VBNV_RECOVERY_RO_SHARED_DATA: + case VB2_RECOVERY_RO_SHARED_DATA: return "Shared data error in read-only firmware"; - case VBNV_RECOVERY_RO_TEST_S3: + case VB2_RECOVERY_RO_TEST_S3: return "Test error from S3Resume()"; - case VBNV_RECOVERY_RO_TEST_LFS: + case VB2_RECOVERY_RO_TEST_LFS: return "Test error from LoadFirmwareSetup()"; - case VBNV_RECOVERY_RO_TEST_LF: + case VB2_RECOVERY_RO_TEST_LF: return "Test error from LoadFirmware()"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NOT_DONE: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NOT_DONE: return "RW firmware check not done"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DEV_MISMATCH: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DEV_MISMATCH: return "RW firmware developer flag mismatch"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_REC_MISMATCH: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_REC_MISMATCH: return "RW firmware recovery flag mismatch"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_KEYBLOCK: return "RW firmware unable to verify key block"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_KEY_ROLLBACK: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_KEY_ROLLBACK: return "RW firmware key version rollback detected"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DATA_KEY_PARSE: return "RW firmware unable to parse data key"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_PREAMBLE: return "RW firmware unable to verify preamble"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_FW_ROLLBACK: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_FW_ROLLBACK: return "RW firmware version rollback detected"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_GET_FW_BODY: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_GET_FW_BODY: return "RW firmware unable to get firmware body"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_HASH_WRONG_SIZE: return "RW firmware hash is wrong size"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_BODY: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_BODY: return "RW firmware unable to verify firmware body"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NO_RO_NORMAL: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NO_RO_NORMAL: return "RW firmware read-only normal path is not supported"; - case VBNV_RECOVERY_RO_FIRMWARE: + case VB2_RECOVERY_RO_FIRMWARE: return "Firmware problem outside of verified boot"; - case VBNV_RECOVERY_RO_TPM_REBOOT: + case VB2_RECOVERY_RO_TPM_REBOOT: return "TPM requires a system reboot (should be transient)"; - case VBNV_RECOVERY_EC_SOFTWARE_SYNC: + case VB2_RECOVERY_EC_SOFTWARE_SYNC: return "EC software sync error"; - case VBNV_RECOVERY_EC_UNKNOWN_IMAGE: + case VB2_RECOVERY_EC_UNKNOWN_IMAGE: return "EC software sync unable to determine active EC image"; - case VBNV_RECOVERY_DEP_EC_HASH: + case VB2_RECOVERY_DEP_EC_HASH: return "EC software sync error obtaining EC image hash"; - case VBNV_RECOVERY_EC_EXPECTED_IMAGE: + case VB2_RECOVERY_EC_EXPECTED_IMAGE: return "EC software sync error " "obtaining expected EC image from BIOS"; - case VBNV_RECOVERY_EC_EXPECTED_HASH: + case VB2_RECOVERY_EC_EXPECTED_HASH: return "EC software sync error " "obtaining expected EC hash from BIOS"; - case VBNV_RECOVERY_EC_HASH_MISMATCH: + case VB2_RECOVERY_EC_HASH_MISMATCH: return "EC software sync error " "comparing expected EC hash and image"; - case VBNV_RECOVERY_EC_UPDATE: + case VB2_RECOVERY_EC_UPDATE: return "EC software sync error updating EC"; - case VBNV_RECOVERY_EC_JUMP_RW: + case VB2_RECOVERY_EC_JUMP_RW: return "EC software sync unable to jump to EC-RW"; - case VBNV_RECOVERY_EC_PROTECT: + case VB2_RECOVERY_EC_PROTECT: return "EC software sync protection error"; - case VBNV_RECOVERY_VB2_SECDATA_INIT: + case VB2_RECOVERY_SECDATA_INIT: return "Secure NVRAM (TPM) initialization error"; - case VBNV_RECOVERY_VB2_GBB_HEADER: + case VB2_RECOVERY_GBB_HEADER: return "Error parsing GBB header"; - case VBNV_RECOVERY_VB2_TPM_CLEAR_OWNER: + case VB2_RECOVERY_TPM_CLEAR_OWNER: return "Error trying to clear TPM owner"; - case VBNV_RECOVERY_VB2_DEV_SWITCH: + case VB2_RECOVERY_DEV_SWITCH: return "Error reading or updating developer switch"; - case VBNV_RECOVERY_VB2_FW_SLOT: + case VB2_RECOVERY_FW_SLOT: return "Error selecting RW firmware slot"; - case VBNV_RECOVERY_RO_UNSPECIFIED: + case VB2_RECOVERY_RO_UNSPECIFIED: return "Unspecified/unknown error in RO firmware"; - case VBNV_RECOVERY_RW_DEV_SCREEN: + case VB2_RECOVERY_RW_DEV_SCREEN: return "User requested recovery from dev-mode warning screen"; - case VBNV_RECOVERY_RW_NO_OS: + case VB2_RECOVERY_RW_NO_OS: return "No OS kernel detected (or kernel rollback attempt?)"; - case VBNV_RECOVERY_RW_INVALID_OS: + case VB2_RECOVERY_RW_INVALID_OS: return "OS kernel failed signature check"; - case VBNV_RECOVERY_DEP_RW_TPM_ERROR: + case VB2_RECOVERY_DEP_RW_TPM_ERROR: return "TPM error in rewritable firmware"; - case VBNV_RECOVERY_RW_DEV_MISMATCH: + case VB2_RECOVERY_RW_DEV_MISMATCH: return "RW firmware in dev mode, but dev switch is off"; - case VBNV_RECOVERY_RW_SHARED_DATA: + case VB2_RECOVERY_RW_SHARED_DATA: return "Shared data error in rewritable firmware"; - case VBNV_RECOVERY_RW_TEST_LK: + case VB2_RECOVERY_RW_TEST_LK: return "Test error from LoadKernel()"; - case VBNV_RECOVERY_DEP_RW_NO_DISK: + case VB2_RECOVERY_DEP_RW_NO_DISK: return "No bootable disk found"; - case VBNV_RECOVERY_TPM_E_FAIL: + case VB2_RECOVERY_TPM_E_FAIL: return "TPM error that was not fixed by reboot"; - case VBNV_RECOVERY_RO_TPM_S_ERROR: + case VB2_RECOVERY_RO_TPM_S_ERROR: return "TPM setup error in read-only firmware"; - case VBNV_RECOVERY_RO_TPM_W_ERROR: + case VB2_RECOVERY_RO_TPM_W_ERROR: return "TPM write error in read-only firmware"; - case VBNV_RECOVERY_RO_TPM_L_ERROR: + case VB2_RECOVERY_RO_TPM_L_ERROR: return "TPM lock error in read-only firmware"; - case VBNV_RECOVERY_RO_TPM_U_ERROR: + case VB2_RECOVERY_RO_TPM_U_ERROR: return "TPM update error in read-only firmware"; - case VBNV_RECOVERY_RW_TPM_R_ERROR: + case VB2_RECOVERY_RW_TPM_R_ERROR: return "TPM read error in rewritable firmware"; - case VBNV_RECOVERY_RW_TPM_W_ERROR: + case VB2_RECOVERY_RW_TPM_W_ERROR: return "TPM write error in rewritable firmware"; - case VBNV_RECOVERY_RW_TPM_L_ERROR: + case VB2_RECOVERY_RW_TPM_L_ERROR: return "TPM lock error in rewritable firmware"; - case VBNV_RECOVERY_EC_HASH_FAILED: + case VB2_RECOVERY_EC_HASH_FAILED: return "EC software sync unable to get EC image hash"; - case VBNV_RECOVERY_EC_HASH_SIZE: + case VB2_RECOVERY_EC_HASH_SIZE: return "EC software sync invalid image hash size"; - case VBNV_RECOVERY_LK_UNSPECIFIED: + case VB2_RECOVERY_LK_UNSPECIFIED: return "Unspecified error while trying to load kernel"; - case VBNV_RECOVERY_RW_NO_DISK: + case VB2_RECOVERY_RW_NO_DISK: return "No bootable storage device in system"; - case VBNV_RECOVERY_RW_NO_KERNEL: + case VB2_RECOVERY_RW_NO_KERNEL: return "No bootable kernel found on disk"; - case VBNV_RECOVERY_RW_BCB_ERROR: + case VB2_RECOVERY_RW_BCB_ERROR: return "BCB partition error on disk"; - case VBNV_RECOVERY_FW_FASTBOOT: + case VB2_RECOVERY_FW_FASTBOOT: return "Fastboot-mode requested in firmware"; - case VBNV_RECOVERY_RO_TPM_REC_HASH_L_ERROR: + case VB2_RECOVERY_RO_TPM_REC_HASH_L_ERROR: return "Recovery hash space lock error in RO firmware"; - case VBNV_RECOVERY_RW_UNSPECIFIED: + case VB2_RECOVERY_RW_UNSPECIFIED: return "Unspecified/unknown error in RW firmware"; - case VBNV_RECOVERY_KE_DM_VERITY: + case VB2_RECOVERY_KE_DM_VERITY: return "DM-verity error"; - case VBNV_RECOVERY_KE_UNSPECIFIED: + case VB2_RECOVERY_KE_UNSPECIFIED: return "Unspecified/unknown error in kernel"; - case VBNV_RECOVERY_US_TEST: + case VB2_RECOVERY_US_TEST: return "Recovery mode test from user-mode"; - case VBNV_RECOVERY_BCB_USER_MODE: + case VB2_RECOVERY_BCB_USER_MODE: return "User-mode requested recovery via BCB"; - case VBNV_RECOVERY_US_FASTBOOT: + case VB2_RECOVERY_US_FASTBOOT: return "User-mode requested fastboot mode"; - case VBNV_RECOVERY_TRAIN_AND_REBOOT: + case VB2_RECOVERY_TRAIN_AND_REBOOT: return "User-mode requested DRAM train and reboot"; - case VBNV_RECOVERY_US_UNSPECIFIED: + case VB2_RECOVERY_US_UNSPECIFIED: return "Unspecified/unknown error in user-mode"; } return "We have no idea what this means"; diff --git a/firmware/lib/vboot_kernel.c b/firmware/lib/vboot_kernel.c index 20272448..c5030ef8 100644 --- a/firmware/lib/vboot_kernel.c +++ b/firmware/lib/vboot_kernel.c @@ -438,7 +438,7 @@ VbError_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params, uint32_t lowest_version = LOWEST_TPM_VERSION; VbError_t retval = VBERROR_UNKNOWN; - int recovery = VBNV_RECOVERY_LK_UNSPECIFIED; + int recovery = VB2_RECOVERY_LK_UNSPECIFIED; /* Clear output params in case we fail */ params->partition_number = 0; @@ -644,11 +644,11 @@ gpt_done: retval = VBERROR_SUCCESS; } else if (found_partitions > 0) { shcall->check_result = VBSD_LKC_CHECK_INVALID_PARTITIONS; - recovery = VBNV_RECOVERY_RW_INVALID_OS; + recovery = VB2_RECOVERY_RW_INVALID_OS; retval = VBERROR_INVALID_KERNEL_FOUND; } else { shcall->check_result = VBSD_LKC_CHECK_NO_PARTITIONS; - recovery = VBNV_RECOVERY_RW_NO_OS; + recovery = VB2_RECOVERY_RW_NO_OS; retval = VBERROR_NO_KERNEL_FOUND; } @@ -656,7 +656,7 @@ load_kernel_exit: /* Store recovery request, if any */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VBERROR_SUCCESS != retval ? - recovery : VBNV_RECOVERY_NOT_REQUESTED); + recovery : VB2_RECOVERY_NOT_REQUESTED); /* Store how much shared data we used, if any */ cparams->shared_data_size = shared->data_used; diff --git a/firmware/lib/vboot_nvstorage.c b/firmware/lib/vboot_nvstorage.c deleted file mode 100644 index 9dc9dc3d..00000000 --- a/firmware/lib/vboot_nvstorage.c +++ /dev/null @@ -1,496 +0,0 @@ -/* 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. - */ - -/* Non-volatile storage routines. - */ -#include "sysincludes.h" - -#include "2crc8.h" -#include "utility.h" -#include "vboot_common.h" -#include "vboot_nvstorage.h" - -/* - * Constants for NV storage. We use this rather than structs and bitfields so - * the data format is consistent across platforms and compilers. - * - * These constants must match the equivalent constants in 2lib/2nvstorage.c. - * (We currently don't share a common header file because we're tring to keep - * the two libs independent, and we hope to deprecate this one.) - */ -#define HEADER_OFFSET 0 -#define HEADER_MASK 0xC0 -#define HEADER_SIGNATURE 0x40 -#define HEADER_FIRMWARE_SETTINGS_RESET 0x20 -#define HEADER_KERNEL_SETTINGS_RESET 0x10 -#define HEADER_WIPEOUT 0x08 - -#define BOOT_OFFSET 1 -#define BOOT_DEBUG_RESET_MODE 0x80 -#define BOOT_DISABLE_DEV_REQUEST 0x40 -#define BOOT_OPROM_NEEDED 0x20 -#define BOOT_BACKUP_NVRAM 0x10 -#define BOOT_TRY_B_COUNT_MASK 0x0F - -#define RECOVERY_OFFSET 2 -#define LOCALIZATION_OFFSET 3 - -#define DEV_FLAGS_OFFSET 4 -#define DEV_BOOT_USB_MASK 0x01 -#define DEV_BOOT_SIGNED_ONLY_MASK 0x02 -#define DEV_BOOT_LEGACY_MASK 0x04 -#define DEV_BOOT_FASTBOOT_FULL_CAP_MASK 0x08 -#define DEV_DEFAULT_BOOT_MASK 0x30 -#define DEV_DEFAULT_BOOT_SHIFT 4 /* Number of bits to shift */ - -#define TPM_FLAGS_OFFSET 5 -#define TPM_CLEAR_OWNER_REQUEST 0x01 -#define TPM_CLEAR_OWNER_DONE 0x02 -#define TPM_REBOOTED 0x04 - -#define RECOVERY_SUBCODE_OFFSET 6 - -#define BOOT2_OFFSET 7 -#define BOOT2_RESULT_MASK 0x03 -#define BOOT2_TRIED 0x04 -#define BOOT2_TRY_NEXT 0x08 -#define BOOT2_PREV_RESULT_MASK 0x30 -#define BOOT2_PREV_RESULT_SHIFT 4 /* Number of bits to shift result */ -#define BOOT2_PREV_TRIED 0x40 - -#define MISC_OFFSET 8 -#define MISC_UNLOCK_FASTBOOT 0x01 -#define MISC_BOOT_ON_AC_DETECT 0x02 -#define MISC_TRY_RO_SYNC 0x04 -#define MISC_BATTERY_CUTOFF_REQUEST 0x08 - -#define KERNEL_MAX_ROLLFORWARD1_OFFSET 9 /* Low bits */ -#define KERNEL_MAX_ROLLFORWARD2_OFFSET 10 -#define KERNEL_MAX_ROLLFORWARD3_OFFSET 13 -#define KERNEL_MAX_ROLLFORWARD4_OFFSET 14 /* High bits */ - -#define KERNEL_FIELD1_OFFSET 11 /* Low bits */ -#define KERNEL_FIELD2_OFFSET 12 /* Low bits */ - -#define CRC_OFFSET 15 - -int VbNvSetup(VbNvContext *context) -{ - uint8_t *raw = context->raw; - - /* Nothing has changed yet. */ - context->raw_changed = 0; - context->regenerate_crc = 0; - - /* Check data for consistency */ - if ((HEADER_SIGNATURE != (raw[HEADER_OFFSET] & HEADER_MASK)) - || (vb2_crc8(raw, CRC_OFFSET) != raw[CRC_OFFSET])) { - /* Data is inconsistent (bad CRC or header); reset defaults */ - memset(raw, 0, VBNV_BLOCK_SIZE); - raw[HEADER_OFFSET] = (HEADER_SIGNATURE | - HEADER_FIRMWARE_SETTINGS_RESET | - HEADER_KERNEL_SETTINGS_RESET); - - /* Regenerate CRC on exit */ - context->regenerate_crc = 1; - } - - return 0; -} - -int VbNvTeardown(VbNvContext *context) -{ - if (context->regenerate_crc) { - context->raw[CRC_OFFSET] = vb2_crc8(context->raw, CRC_OFFSET); - context->regenerate_crc = 0; - context->raw_changed = 1; - } - - return 0; -} - -int VbNvGet(VbNvContext *context, VbNvParam param, uint32_t *dest) -{ - const uint8_t *raw = context->raw; - - switch (param) { - case VBNV_FIRMWARE_SETTINGS_RESET: - *dest = (raw[HEADER_OFFSET] & HEADER_FIRMWARE_SETTINGS_RESET ? - 1 : 0); - return 0; - - case VBNV_KERNEL_SETTINGS_RESET: - *dest = (raw[HEADER_OFFSET] & HEADER_KERNEL_SETTINGS_RESET ? - 1 : 0); - return 0; - - case VBNV_DEBUG_RESET_MODE: - *dest = (raw[BOOT_OFFSET] & BOOT_DEBUG_RESET_MODE ? 1 : 0); - return 0; - - case VBNV_TRY_B_COUNT: - case VBNV_FW_TRY_COUNT: - *dest = raw[BOOT_OFFSET] & BOOT_TRY_B_COUNT_MASK; - return 0; - - case VBNV_RECOVERY_REQUEST: - *dest = raw[RECOVERY_OFFSET]; - return 0; - - case VBNV_RECOVERY_SUBCODE: - *dest = raw[RECOVERY_SUBCODE_OFFSET]; - return 0; - - case VBNV_LOCALIZATION_INDEX: - *dest = raw[LOCALIZATION_OFFSET]; - return 0; - - case VBNV_KERNEL_FIELD: - *dest = (raw[KERNEL_FIELD1_OFFSET] - | (raw[KERNEL_FIELD2_OFFSET] << 8)); - return 0; - - case VBNV_DEV_BOOT_USB: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_USB_MASK ? 1 : 0); - return 0; - - case VBNV_DEV_BOOT_LEGACY: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_LEGACY_MASK ? 1 : 0); - return 0; - - case VBNV_DEV_DEFAULT_BOOT: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_DEFAULT_BOOT_MASK) - >> DEV_DEFAULT_BOOT_SHIFT; - return 0; - - case VBNV_DEV_BOOT_SIGNED_ONLY: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_SIGNED_ONLY_MASK ? - 1 : 0); - return 0; - - case VBNV_DEV_BOOT_FASTBOOT_FULL_CAP: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_FASTBOOT_FULL_CAP_MASK - ? 1 : 0); - return 0; - - case VBNV_DISABLE_DEV_REQUEST: - *dest = (raw[BOOT_OFFSET] & BOOT_DISABLE_DEV_REQUEST ? 1 : 0); - return 0; - - case VBNV_OPROM_NEEDED: - *dest = (raw[BOOT_OFFSET] & BOOT_OPROM_NEEDED ? 1 : 0); - return 0; - - case VBNV_CLEAR_TPM_OWNER_REQUEST: - *dest = (raw[TPM_FLAGS_OFFSET] & TPM_CLEAR_OWNER_REQUEST ? - 1 : 0); - return 0; - - case VBNV_CLEAR_TPM_OWNER_DONE: - *dest = (raw[TPM_FLAGS_OFFSET] & TPM_CLEAR_OWNER_DONE ? 1 : 0); - return 0; - - case VBNV_TPM_REQUESTED_REBOOT: - *dest = (raw[TPM_FLAGS_OFFSET] & TPM_REBOOTED ? 1 : 0); - return 0; - - case VBNV_BACKUP_NVRAM_REQUEST: - *dest = (raw[BOOT_OFFSET] & BOOT_BACKUP_NVRAM ? 1 : 0); - return 0; - - case VBNV_FW_TRY_NEXT: - *dest = (raw[BOOT2_OFFSET] & BOOT2_TRY_NEXT ? 1 : 0); - return 0; - - case VBNV_FW_TRIED: - *dest = (raw[BOOT2_OFFSET] & BOOT2_TRIED ? 1 : 0); - return 0; - - case VBNV_FW_RESULT: - *dest = raw[BOOT2_OFFSET] & BOOT2_RESULT_MASK; - return 0; - - case VBNV_FW_PREV_TRIED: - *dest = (raw[BOOT2_OFFSET] & BOOT2_PREV_TRIED ? 1 : 0); - return 0; - - case VBNV_FW_PREV_RESULT: - *dest = (raw[BOOT2_OFFSET] & BOOT2_PREV_RESULT_MASK) - >> BOOT2_PREV_RESULT_SHIFT; - return 0; - - case VBNV_FW_REQ_WIPEOUT: - *dest = (raw[HEADER_OFFSET] & HEADER_WIPEOUT) ? 1 : 0; - return 0; - - case VBNV_FASTBOOT_UNLOCK_IN_FW: - *dest = (raw[MISC_OFFSET] & MISC_UNLOCK_FASTBOOT) ? 1 : 0; - return 0; - - case VBNV_BOOT_ON_AC_DETECT: - *dest = (raw[MISC_OFFSET] & MISC_BOOT_ON_AC_DETECT) ? 1 : 0; - return 0; - - case VBNV_TRY_RO_SYNC: - *dest = (raw[MISC_OFFSET] & MISC_TRY_RO_SYNC) ? 1 : 0; - return 0; - - case VBNV_BATTERY_CUTOFF_REQUEST: - *dest = (raw[MISC_OFFSET] & MISC_BATTERY_CUTOFF_REQUEST) - ? 1 : 0; - return 0; - - case VBNV_KERNEL_MAX_ROLLFORWARD: - *dest = (raw[KERNEL_MAX_ROLLFORWARD1_OFFSET] - | (raw[KERNEL_MAX_ROLLFORWARD2_OFFSET] << 8) - | (raw[KERNEL_MAX_ROLLFORWARD3_OFFSET] << 16) - | (raw[KERNEL_MAX_ROLLFORWARD4_OFFSET] << 24)); - return 0; - - default: - return 1; - } -} - -int VbNvSet(VbNvContext *context, VbNvParam param, uint32_t value) -{ - uint8_t *raw = context->raw; - uint32_t current; - - /* If not changing the value, don't regenerate the CRC. */ - if (0 == VbNvGet(context, param, ¤t) && current == value) - return 0; - - switch (param) { - case VBNV_FIRMWARE_SETTINGS_RESET: - if (value) - raw[HEADER_OFFSET] |= HEADER_FIRMWARE_SETTINGS_RESET; - else - raw[HEADER_OFFSET] &= ~HEADER_FIRMWARE_SETTINGS_RESET; - break; - - case VBNV_KERNEL_SETTINGS_RESET: - if (value) - raw[HEADER_OFFSET] |= HEADER_KERNEL_SETTINGS_RESET; - else - raw[HEADER_OFFSET] &= ~HEADER_KERNEL_SETTINGS_RESET; - break; - - case VBNV_DEBUG_RESET_MODE: - if (value) - raw[BOOT_OFFSET] |= BOOT_DEBUG_RESET_MODE; - else - raw[BOOT_OFFSET] &= ~BOOT_DEBUG_RESET_MODE; - break; - - case VBNV_TRY_B_COUNT: - case VBNV_FW_TRY_COUNT: - /* Clip to valid range. */ - if (value > BOOT_TRY_B_COUNT_MASK) - value = BOOT_TRY_B_COUNT_MASK; - - raw[BOOT_OFFSET] &= ~BOOT_TRY_B_COUNT_MASK; - raw[BOOT_OFFSET] |= (uint8_t)value; - break; - - case VBNV_RECOVERY_REQUEST: - /* - * Map values outside the valid range to the legacy reason, - * since we can't determine if we're called from kernel or user - * mode. - */ - if (value > 0xFF) - value = VBNV_RECOVERY_LEGACY; - raw[RECOVERY_OFFSET] = (uint8_t)value; - break; - - case VBNV_RECOVERY_SUBCODE: - raw[RECOVERY_SUBCODE_OFFSET] = (uint8_t)value; - break; - - case VBNV_LOCALIZATION_INDEX: - /* Map values outside the valid range to the default index. */ - if (value > 0xFF) - value = 0; - raw[LOCALIZATION_OFFSET] = (uint8_t)value; - break; - - case VBNV_KERNEL_FIELD: - raw[KERNEL_FIELD1_OFFSET] = (uint8_t)(value); - raw[KERNEL_FIELD2_OFFSET] = (uint8_t)(value >> 8); - break; - - case VBNV_DEV_BOOT_USB: - if (value) - raw[DEV_FLAGS_OFFSET] |= DEV_BOOT_USB_MASK; - else - raw[DEV_FLAGS_OFFSET] &= ~DEV_BOOT_USB_MASK; - break; - - case VBNV_DEV_BOOT_LEGACY: - if (value) - raw[DEV_FLAGS_OFFSET] |= DEV_BOOT_LEGACY_MASK; - else - raw[DEV_FLAGS_OFFSET] &= ~DEV_BOOT_LEGACY_MASK; - break; - - case VBNV_DEV_DEFAULT_BOOT: - /* Map out of range values to boot disk */ - if (value > (DEV_DEFAULT_BOOT_MASK >> - DEV_DEFAULT_BOOT_SHIFT)) - value = VBNV_DEV_DEFAULT_BOOT_DISK; - - raw[DEV_FLAGS_OFFSET] &= ~DEV_DEFAULT_BOOT_MASK; - raw[DEV_FLAGS_OFFSET] |= (uint8_t)value << - DEV_DEFAULT_BOOT_SHIFT; - break; - - case VBNV_DEV_BOOT_SIGNED_ONLY: - if (value) - raw[DEV_FLAGS_OFFSET] |= DEV_BOOT_SIGNED_ONLY_MASK; - else - raw[DEV_FLAGS_OFFSET] &= ~DEV_BOOT_SIGNED_ONLY_MASK; - break; - - case VBNV_DEV_BOOT_FASTBOOT_FULL_CAP: - if (value) - raw[DEV_FLAGS_OFFSET] |= - DEV_BOOT_FASTBOOT_FULL_CAP_MASK; - else - raw[DEV_FLAGS_OFFSET] &= - ~DEV_BOOT_FASTBOOT_FULL_CAP_MASK; - break; - - case VBNV_DISABLE_DEV_REQUEST: - if (value) - raw[BOOT_OFFSET] |= BOOT_DISABLE_DEV_REQUEST; - else - raw[BOOT_OFFSET] &= ~BOOT_DISABLE_DEV_REQUEST; - break; - - case VBNV_OPROM_NEEDED: - if (value) - raw[BOOT_OFFSET] |= BOOT_OPROM_NEEDED; - else - raw[BOOT_OFFSET] &= ~BOOT_OPROM_NEEDED; - break; - - case VBNV_CLEAR_TPM_OWNER_REQUEST: - if (value) - raw[TPM_FLAGS_OFFSET] |= TPM_CLEAR_OWNER_REQUEST; - else - raw[TPM_FLAGS_OFFSET] &= ~TPM_CLEAR_OWNER_REQUEST; - break; - - case VBNV_CLEAR_TPM_OWNER_DONE: - if (value) - raw[TPM_FLAGS_OFFSET] |= TPM_CLEAR_OWNER_DONE; - else - raw[TPM_FLAGS_OFFSET] &= ~TPM_CLEAR_OWNER_DONE; - break; - - case VBNV_TPM_REQUESTED_REBOOT: - if (value) - raw[TPM_FLAGS_OFFSET] |= TPM_REBOOTED; - else - raw[TPM_FLAGS_OFFSET] &= ~TPM_REBOOTED; - break; - - case VBNV_BACKUP_NVRAM_REQUEST: - if (value) - raw[BOOT_OFFSET] |= BOOT_BACKUP_NVRAM; - else - raw[BOOT_OFFSET] &= ~BOOT_BACKUP_NVRAM; - break; - - case VBNV_FW_TRY_NEXT: - if (value) - raw[BOOT2_OFFSET] |= BOOT2_TRY_NEXT; - else - raw[BOOT2_OFFSET] &= ~BOOT2_TRY_NEXT; - break; - - case VBNV_FW_TRIED: - if (value) - raw[BOOT2_OFFSET] |= BOOT2_TRIED; - else - raw[BOOT2_OFFSET] &= ~BOOT2_TRIED; - break; - - case VBNV_FW_RESULT: - /* Map out of range values to unknown */ - if (value > BOOT2_RESULT_MASK) - value = VBNV_FW_RESULT_UNKNOWN; - - raw[BOOT2_OFFSET] &= ~BOOT2_RESULT_MASK; - raw[BOOT2_OFFSET] |= (uint8_t)value; - break; - - case VBNV_FW_PREV_TRIED: - if (value) - raw[BOOT2_OFFSET] |= BOOT2_PREV_TRIED; - else - raw[BOOT2_OFFSET] &= ~BOOT2_PREV_TRIED; - break; - - case VBNV_FW_PREV_RESULT: - /* Map out of range values to unknown */ - if (value > BOOT2_RESULT_MASK) - value = VBNV_FW_RESULT_UNKNOWN; - - raw[BOOT2_OFFSET] &= ~BOOT2_PREV_RESULT_MASK; - raw[BOOT2_OFFSET] |= (uint8_t)value << BOOT2_PREV_RESULT_SHIFT; - break; - - case VBNV_FW_REQ_WIPEOUT: - if (value) - raw[HEADER_OFFSET] |= HEADER_WIPEOUT; - else - raw[HEADER_OFFSET] &= ~HEADER_WIPEOUT; - break; - - case VBNV_FASTBOOT_UNLOCK_IN_FW: - if (value) - raw[MISC_OFFSET] |= MISC_UNLOCK_FASTBOOT; - else - raw[MISC_OFFSET] &= ~MISC_UNLOCK_FASTBOOT; - break; - - case VBNV_BOOT_ON_AC_DETECT: - if (value) - raw[MISC_OFFSET] |= MISC_BOOT_ON_AC_DETECT; - else - raw[MISC_OFFSET] &= ~MISC_BOOT_ON_AC_DETECT; - break; - - case VBNV_TRY_RO_SYNC: - if (value) - raw[MISC_OFFSET] |= MISC_TRY_RO_SYNC; - else - raw[MISC_OFFSET] &= ~MISC_TRY_RO_SYNC; - break; - - case VBNV_BATTERY_CUTOFF_REQUEST: - if (value) - raw[MISC_OFFSET] |= MISC_BATTERY_CUTOFF_REQUEST; - else - raw[MISC_OFFSET] &= ~MISC_BATTERY_CUTOFF_REQUEST; - break; - - case VBNV_KERNEL_MAX_ROLLFORWARD: - raw[KERNEL_MAX_ROLLFORWARD1_OFFSET] = (uint8_t)(value); - raw[KERNEL_MAX_ROLLFORWARD2_OFFSET] = (uint8_t)(value >> 8); - raw[KERNEL_MAX_ROLLFORWARD3_OFFSET] = (uint8_t)(value >> 16); - raw[KERNEL_MAX_ROLLFORWARD4_OFFSET] = (uint8_t)(value >> 24); - break; - - default: - return 1; - } - - /* Need to regenerate CRC, since the value changed. */ - context->regenerate_crc = 1; - return 0; -} diff --git a/firmware/lib/vboot_ui.c b/firmware/lib/vboot_ui.c index c44b70b1..4d913f0e 100644 --- a/firmware/lib/vboot_ui.c +++ b/firmware/lib/vboot_ui.c @@ -25,7 +25,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" static void VbAllowUsbBoot(struct vb2_context *ctx) { @@ -84,7 +83,7 @@ uint32_t VbTryUsb(struct vb2_context *ctx, VbCommonParams *cparams) * recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); } return retval; } @@ -182,9 +181,9 @@ VbError_t vb2_developer_ui(struct vb2_context *ctx, VbCommonParams *cparams) /* Check if the default is to boot using disk, usb, or legacy */ uint32_t default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT); - if(default_boot == VBNV_DEV_DEFAULT_BOOT_USB) + if(default_boot == VB2_DEV_DEFAULT_BOOT_USB) use_usb = 1; - if(default_boot == VBNV_DEV_DEFAULT_BOOT_LEGACY) + if(default_boot == VB2_DEV_DEFAULT_BOOT_LEGACY) use_legacy = 1; /* Handle GBB flag override */ @@ -315,7 +314,7 @@ VbError_t vb2_developer_ui(struct vb2_context *ctx, VbCommonParams *cparams) */ VB2_DEBUG("going to recovery\n"); vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_RW_DEV_SCREEN); + VB2_RECOVERY_RW_DEV_SCREEN); VbAudioClose(audio); return VBERROR_LOAD_KERNEL_RECOVERY; } @@ -427,8 +426,8 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) /* * We have to save the reason here so that it will survive * coming up three-finger-salute. We're saving it in - * VBNV_RECOVERY_SUBCODE to avoid a recovery loop. - * If we save the reason in VBNV_RECOVERY_REQUEST, we will come + * VB2_RECOVERY_SUBCODE to avoid a recovery loop. + * If we save the reason in VB2_RECOVERY_REQUEST, we will come * back here, thus, we won't be able to give a user a chance to * reboot to workaround a boot hiccup. */ @@ -466,7 +465,7 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) * us stuck in recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); if (VBERROR_SUCCESS == retval) break; /* Found a recovery kernel */ diff --git a/firmware/lib/vboot_ui_menu.c b/firmware/lib/vboot_ui_menu.c index b4fdd25e..d1c2b1d3 100644 --- a/firmware/lib/vboot_ui_menu.c +++ b/firmware/lib/vboot_ui_menu.c @@ -23,7 +23,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" static void VbAllowUsbBootMenu(struct vb2_context *ctx) { @@ -84,7 +83,7 @@ uint32_t VbTryUsbMenu(struct vb2_context *ctx, VbCommonParams *cparams) * recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); } return retval; } @@ -355,13 +354,13 @@ VbError_t vb2_update_menu(struct vb2_context *ctx) switch(current_menu_idx) { case VB_WARN_OPTIONS: switch(default_boot) { - case VBNV_DEV_DEFAULT_BOOT_DISK: + case VB2_DEV_DEFAULT_BOOT_DISK: next_menu_idx = VB_DEV_DISK; break; - case VBNV_DEV_DEFAULT_BOOT_USB: + case VB2_DEV_DEFAULT_BOOT_USB: next_menu_idx = VB_DEV_USB; break; - case VBNV_DEV_DEFAULT_BOOT_LEGACY: + case VB2_DEV_DEFAULT_BOOT_LEGACY: next_menu_idx = VB_DEV_LEGACY; break; } @@ -675,9 +674,9 @@ VbError_t vb2_developer_menu(struct vb2_context *ctx, VbCommonParams *cparams) /* Check if the default is to boot using disk, usb, or legacy */ default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT); - if(default_boot == VBNV_DEV_DEFAULT_BOOT_USB) + if(default_boot == VB2_DEV_DEFAULT_BOOT_USB) use_usb = 1; - if(default_boot == VBNV_DEV_DEFAULT_BOOT_LEGACY) + if(default_boot == VB2_DEV_DEFAULT_BOOT_LEGACY) use_legacy = 1; /* Handle GBB flag override */ @@ -990,8 +989,8 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) /* * We have to save the reason here so that it will survive * coming up three-finger-salute. We're saving it in - * VBNV_RECOVERY_SUBCODE to avoid a recovery loop. - * If we save the reason in VBNV_RECOVERY_REQUEST, we will come + * VB2_RECOVERY_SUBCODE to avoid a recovery loop. + * If we save the reason in VB2_RECOVERY_REQUEST, we will come * back here, thus, we won't be able to give a user a chance to * reboot to workaround a boot hiccup. */ @@ -1040,7 +1039,7 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) * us stuck in recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); if (VBERROR_SUCCESS == retval) break; /* Found a recovery kernel */ |