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

common/cmd_cros.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 55 matching lines @@
                 "display <gbbaddr> <screen#> - display the screen\n"
                 "bmpblk info <gbbaddr> <screen#>    - print the screen info\n"),
 #endif /* CONFIG_CHROMEOS_BMPBLK */
         U_BOOT_CMD_MKENT(fmap, 2, 1, do_fmap,
                 "Find and print flash map",
                 "addr len\n    - Find and print flash map "
                 "in memory[addr, addr+len]\n"),
         U_BOOT_CMD_MKENT(load_fw, 3, 1, do_load_fw,
                 "Load firmware from memory "
                 "(you have to download the image before running this)",
-                "addr len kkey\n    - Wrapper of LoadFirmware."
+                "addr len shdata\n    - Wrapper of LoadFirmware."
                 "Load firmware from [addr, addr+len] and "
-                "store loaded kernel key at kkey\n"),
+                "store shared data at shdata\n"),
         U_BOOT_CMD_MKENT(load_k, 3, 1, do_load_k,
                 "Load kernel from the boot device",
-                "addr len kkey\n    - Load kernel to [addr, addr+len]\n"),
+                "addr len shdata\n    - Load kernel to [addr, addr+len] and\n"
+                "modify shared data at shdata\n"),
         U_BOOT_CMD_MKENT(help, 1, 1, do_cros_help,
                 "show this message",
                 "[action]")
 };
 
 int do_cros(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
         cmd_tbl_t *c;
 
         if (argc < 2)
@@ skipping 286 matching lines @@
         cxt->cur += count;
 
         return count;
 }
 
 int do_load_fw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
         LoadFirmwareParams params;
         VbNvContext vnc;
         struct context_t context;
-        void *gbb, *block[2];
-        GoogleBinaryBlockHeader *gbbh;
+        void *block[2];
         uint64_t *psize[2];
         VbKeyBlockHeader *kbh;
         VbFirmwarePreambleHeader *fph;
         int i, status;
         firmware_storage_t f = {
                 .seek = mem_seek,
                 .read = mem_read,
                 .context = (void *) &context
         };
 
         if (argc != 4)
                 USAGE(1, cmdtp, "Wrong number of arguments\n");
 
         context.begin = (void *) simple_strtoul(argv[1], NULL, 16);
         context.cur = context.begin;
         context.end = context.begin + simple_strtoul(argv[2], NULL, 16);
 
         GetFirmwareBody_setup(&f, CONFIG_OFFSET_FW_A_DATA,
                         CONFIG_OFFSET_FW_B_DATA);
 
-        gbb = context.begin + CONFIG_OFFSET_GBB;
-        gbbh = (GoogleBinaryBlockHeader *) gbb;
-        params.firmware_root_key_blob = gbb + gbbh->rootkey_offset;
+        params.gbb_data = context.begin + CONFIG_OFFSET_GBB;
+        params.gbb_size = CONFIG_LENGTH_GBB;
 
         debug("do_load_fw: params.firmware_root_key_blob:\t%p\n",
                         params.firmware_root_key_blob);
 
         params.verification_block_0 = context.begin + CONFIG_OFFSET_FW_A_KEY;
         params.verification_block_1 = context.begin + CONFIG_OFFSET_FW_B_KEY;
 
         block[0] = params.verification_block_0;
         block[1] = params.verification_block_1;
         psize[0] =  &params.verification_size_0;
         psize[1] =  &params.verification_size_1;
         for (i = 0; i < 2; i++) {
                 kbh = (VbKeyBlockHeader *) block[i];
                 fph = (VbFirmwarePreambleHeader *)
                         (block[i] + kbh->key_block_size);
 
                 *psize[i] = kbh->key_block_size + fph->preamble_size;
 
                 debug("do_load_fw: params.verification_block_%d:\t%p\n",
                                 i, block[i]);
                 debug("do_load_fw: params.verification_size_%d:\t%08llx\n",
                                 i, *psize[i]);
         }
 
-        params.kernel_sign_key_blob =
+        params.shared_data_blob =
                 (uint8_t *) simple_strtoul(argv[3], NULL, 16);
-        params.kernel_sign_key_size = LOAD_FIRMWARE_KEY_BLOB_REC_SIZE;
+        params.shared_data_size = VB_SHARED_DATA_REC_SIZE;
 
-        debug("do_load_fw: params.kernel_sign_key_blob:\t%p\n",
-                        params.kernel_sign_key_blob);
-        debug("do_load_fw: params.kernel_sign_key_size:\t%08llx\n",
-                        params.kernel_sign_key_size);
+        debug("do_load_fw: params.shared_data_blob:\t%p\n",
+                        params.shared_data_blob);
+        debug("do_load_fw: params.shared_data_size:\t%08llx\n",
+                        params.shared_data_size);
 
         params.caller_internal = &f;
 
         params.boot_flags = 0;
 
         /* TODO: load vnc.raw from NV storage */
         params.nv_context = &vnc;
 
         status = LoadFirmware(&params);
 
@@ skipping 30 matching lines @@
         VbNvContext vnc;
         block_dev_desc_t *dev_desc;
         int i, status;
 
         if (argc != 4)
                 USAGE(1, cmdtp, "Wrong number of arguments\n");
 
         if ((dev_desc = get_bootdev()) == NULL)
                 USAGE(1, cmdtp, "No boot device set yet\n");
 
-        par.header_sign_key_blob =
+        par.shared_data_blob =
                 (uint8_t *) simple_strtoul(argv[3], NULL, 16);
+        par.shared_data_size = VB_SHARED_DATA_REC_SIZE;
+
         par.bytes_per_lba = (uint64_t) dev_desc->blksz;
         par.ending_lba = (uint64_t) get_limit() - 1;
         par.kernel_buffer = (void *) simple_strtoul(argv[1], NULL, 16);
         par.kernel_buffer_size = (uint64_t) simple_strtoul(argv[2], NULL, 16);
         par.boot_flags = BOOT_FLAG_DEVELOPER | BOOT_FLAG_SKIP_ADDR_CHECK;
 
+        /* TODO: load GBB; see do_load_fw() */
+        par.gbb_data = NULL;
+        par.gbb_size = 0;
+
         /* TODO: load vnc.raw from NV storage */
         par.nv_context = &vnc;
 
         status = LoadKernel(&par);
 
         if (vnc.raw_changed) {
                 /* TODO: save vnc.raw to NV storage */
         }
 
         switch (status) {
@@ skipping 38 matching lines @@
                 return _do_help(&cmd_cros_sub[0], ARRAY_SIZE(cmd_cros_sub),
                                 cmdtp, flag, argc, argv);
 
         c = find_cmd_tbl(argv[1], &cmd_cros_sub[0], ARRAY_SIZE(cmd_cros_sub));
         if (!c)
                 USAGE(1, cmdtp, "Unrecognized action: %s\n", argv[1]);
 
         cmd_usage(c);
         return 0;
 }