Changes to u-boot-next to match VBoot reference change

common/cmd_cros_bootstub.c

 /*
  * Copyright (c) 2011 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.
  *
  * Alternatively, this software may be distributed under the terms of the
  * GNU General Public License ("GPL") version 2 as published by the Free
  * Software Foundation.
  */
 
@@ skipping 110 matching lines @@
         return 0;
 }
 
 /*
  * Initialize <params> for LoadFirmware().
  *
  * Return 0 if success, non-zero if error.
  */
 int init_params(LoadFirmwareParams *params, firmware_storage_t *file,
                 const off_t vblock_offset[], int boot_flags,
-                void *kernel_sign_key_blob, uint64_t kernel_sign_key_size)
+                void *vb_shared_data_blob, uint64_t vb_shared_data_size)
 {
-        GoogleBinaryBlockHeader gbbh;
-
         memset(params, '\0', sizeof(*params));
 
-        /* read gbb header */
-        if (read_firmware_device(file, CONFIG_OFFSET_GBB, &gbbh,
-                                sizeof(gbbh))) {
-                debug(PREFIX "read gbb header fail\n");
+        /* read gbb */
+        params->gbb_size = CONFIG_LENGTH_GBB;
+        params->gbb_data = malloc(CONFIG_LENGTH_GBB);
+        if (!params->gbb_data) {
+                debug(PREFIX "cannot malloc gbb\n");
+                return -1;
+        }
+        if (read_firmware_device(file, CONFIG_OFFSET_GBB,
+                                params->gbb_data,
+                                params->gbb_size)) {
+                debug(PREFIX "read gbb fail\n");
                 return -1;
         }
 
-        /* read root key from gbb */
-        params->firmware_root_key_blob = malloc(gbbh.rootkey_size);
-        if (!params->firmware_root_key_blob) {
-                debug(PREFIX "cannot malloc firmware_root_key_blob\n");
-                return -1;
-        }
-        if (read_firmware_device(file, CONFIG_OFFSET_GBB + gbbh.rootkey_offset,
-                                params->firmware_root_key_blob,
-                                gbbh.rootkey_size)) {
-                debug(PREFIX "read root key fail\n");
-                return -1;
-        }
-
         /* read verification block 0 and 1 */
         if (read_verification_block(file, vblock_offset[0],
                                 &params->verification_block_0,
                                 &params->verification_size_0)) {
                 debug(PREFIX "read verification block 0 fail\n");
                 return -1;
         }
         if (read_verification_block(file, vblock_offset[1],
                                 &params->verification_block_1,
                                 &params->verification_size_1)) {
                 debug(PREFIX "read verification block 1 fail\n");
                 return -1;
         }
 
         params->boot_flags = boot_flags;
         params->caller_internal = file;
-        params->kernel_sign_key_blob = kernel_sign_key_blob;
-        params->kernel_sign_key_size = kernel_sign_key_size;
+        params->shared_data_blob = vb_shared_data_blob;
+        params->shared_data_size = vb_shared_data_size;
 
         return 0;
 }
 
 /*
  * Load and verify rewritable firmware. A wrapper of LoadFirmware() function.
  *
  * Returns what is returned by LoadFirmware().
  *
  * For documentation of return values of LoadFirmware(), <primary_firmware>, and
  * <boot_flags>, please refer to
  * vboot_reference/firmware/include/load_firmware_fw.h
  *
- * The kernel key found in firmware image is stored in <kernel_sign_key_blob>
- * and <kernel_sign_key_size>.
+ * The shared data blob for the firmware image is stored in
+ * <vb_shared_data_blob> and <vb_shared_data_size>.
  *
  * Pointer to loaded firmware is stored in <firmware_data_ptr>.
  */
 int load_firmware(uint8_t **firmware_data_ptr,
                 int primary_firmware, int boot_flags,
-                void *kernel_sign_key_blob, uint64_t kernel_sign_key_size)
+                void *vb_shared_data_blob, uint64_t vb_shared_data_size)
 {
         /*
          * Offsets of verification blocks are
          * vblock_offset[primary_firmware][verification_block_index].
          *
          * Offsets of firmware data are
          * data_offset[primary_firmware][firmware_data_index].
          */
         const off_t vblock_offset[2][2] = {
                 { CONFIG_OFFSET_FW_A_KEY, CONFIG_OFFSET_FW_B_KEY },
                 { CONFIG_OFFSET_FW_B_KEY, CONFIG_OFFSET_FW_A_KEY },
         };
         const off_t data_offset[2][2] = {
                 { CONFIG_OFFSET_FW_A_DATA, CONFIG_OFFSET_FW_B_DATA },
                 { CONFIG_OFFSET_FW_B_DATA, CONFIG_OFFSET_FW_A_DATA },
         };
         int status = LOAD_FIRMWARE_RECOVERY;
         LoadFirmwareParams params;
         firmware_storage_t file;
 
         if (init_firmware_storage(&file)) {
                 debug(PREFIX "init_firmware_storage fail\n");
                 return FIRMWARE_RECOVERY;
         }
         GetFirmwareBody_setup(&file, data_offset[primary_firmware][0],
                         data_offset[primary_firmware][1]);
 
         if (init_params(&params, &file, vblock_offset[primary_firmware],
-                                boot_flags, kernel_sign_key_blob,
-                                kernel_sign_key_size)) {
+                                boot_flags, vb_shared_data_blob,
+                                vb_shared_data_size)) {
                 debug(PREFIX "init LoadFirmware parameters fail\n");
         } else
                 status = LoadFirmware(&params);
 
         if (status == LOAD_FIRMWARE_SUCCESS) {
                 debug(PREFIX "will jump to rewritable firmware %d\n",
                                 (int) params.firmware_index);
                 *firmware_data_ptr = file.firmware_body[params.firmware_index];
 
                 /* set to null so that *firmware_data_ptr is not disposed */
                 file.firmware_body[params.firmware_index] = NULL;
         }
 
         release_firmware_storage(&file);
         GetFirmwareBody_dispose(&file);
 
-        if (params.firmware_root_key_blob)
-                free(params.firmware_root_key_blob);
+        if (params.gbb_data)
+                free(params.gbb_data);
         if (params.verification_block_0)
                 free(params.verification_block_0);
         if (params.verification_block_1)
                 free(params.verification_block_1);
 
         return status;
 }
 
 /*
  * Read recovery firmware into <firmware_data_buffer>.
@@ skipping 59 matching lines @@
 
         /* FIXME(clchiou) Bring up a sad face as boot has failed */
         while (1);
 }
 
 int do_cros_bootstub(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
         int status = LOAD_FIRMWARE_RECOVERY;
         int primary_firmware, boot_flags = 0;
         uint8_t *firmware_data;
-        uint8_t *kernel_sign_key_blob = (uint8_t *) CONFIG_KERNEL_SIGN_KEY_BLOB;
-        uint64_t kernel_sign_key_size = CONFIG_KERNEL_SIGN_KEY_SIZE;
+        uint8_t *vb_shared_data_blob = (uint8_t *) CONFIG_VB_SHARED_DATA_BLOB;
+        uint64_t vb_shared_data_size = CONFIG_VB_SHARED_DATA_SIZE;
 
         /* TODO Start initializing chipset */
 
         if (is_firmware_write_protect_gpio_asserted())
                 WARN_ON_FAILURE(lock_down_eeprom());
 
         WARN_ON_FAILURE(initialize_tpm());
 
         if (is_s3_resume() && !is_debug_reset_mode_field_containing_cookie()) {
                 WARN_ON_FAILURE(lock_tpm());
                 /* TODO Jump to S3 resume pointer and should never return */
                 return 0;
         }
 
         if (is_recovery_mode_gpio_asserted() ||
             is_recovery_mode_field_containing_cookie()) {
                 debug(PREFIX "boot recovery firmware\n");
         } else {
                 if (is_try_firmware_b_field_containing_cookie())
                         primary_firmware = FIRMWARE_B;
                 else
                         primary_firmware = FIRMWARE_A;
 
                 if (is_developer_mode_gpio_asserted())
                         boot_flags |= BOOT_FLAG_DEVELOPER;
 
                 status = load_firmware(&firmware_data,
                                 primary_firmware, boot_flags,
-                                kernel_sign_key_blob, kernel_sign_key_size);
+                                vb_shared_data_blob, vb_shared_data_size);
         }
 
         WARN_ON_FAILURE(lock_tpm_rewritable_firmware_index());
 
         if (status == LOAD_FIRMWARE_SUCCESS) {
                 jump_to_firmware((void (*)(void)) firmware_data);
 
                 debug(PREFIX "error: should never reach here! "
                                 "jump to recovery firmware\n");
         }
 
         debug(PREFIX "jump to recovery firmware and never return\n");
 
         firmware_data = malloc(CONFIG_LENGTH_RECOVERY);
         WARN_ON_FAILURE(load_firmware_data(firmware_data));
         jump_to_firmware((void (*)(void)) firmware_data);
 
         debug(PREFIX "error: should never reach here!\n");
         return 1;
 }
 
 U_BOOT_CMD(cros_bootstub, 1, 1, do_cros_bootstub, "verified boot stub firmware",
                 NULL);