1589 lines
43 KiB
C
1589 lines
43 KiB
C
// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
|
|
/*
|
|
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <common.h>
|
|
#include <linux/kernel.h>
|
|
#include <amlogic/aml_efuse.h>
|
|
#include <amlogic/cpu_id.h>
|
|
#include <amlogic/storage.h>
|
|
#include <partition_table.h>
|
|
#include <fastboot.h>
|
|
#include <emmc_partitions.h>
|
|
#include <asm/arch/efuse.h>
|
|
#include <amlogic/aml_rollback.h>
|
|
#include <part.h>
|
|
#include <cli.h>
|
|
#include <emmc_partitions.h>
|
|
#include <amlogic/store_wrapper.h>
|
|
|
|
#if defined(CONFIG_EFUSE_OBJ_API) && defined(CONFIG_CMD_EFUSE)
|
|
extern efuse_obj_field_t efuse_field;
|
|
#endif//#ifdef CONFIG_EFUSE_OBJ_API
|
|
|
|
typedef boot_img_hdr_t boot_img_hdr;
|
|
|
|
#define debugP(fmt...) //printf("[DbgBootSta]L%d:", __LINE__),printf(fmt)
|
|
#define errorP(fmt...) printf("ErrBootSta(L%d):", __LINE__),printf(fmt)
|
|
#define wrnP(fmt...) printf("wrn:"fmt)
|
|
#define MsgP(fmt...) printf("[BootSta]"fmt)
|
|
|
|
#define BOOTLOADER_OFFSET 512
|
|
#define BOOTLOADER_MAX_SIZE (4 * 1024 * 1024)
|
|
#define MIB_SIZE (1024 * 1024)
|
|
#define GPT_OFFSET 0x3DFE00
|
|
#define GPT2_OFFSET 0x3EC600
|
|
#define DTS_GPT_OFFSET 0x3E0000
|
|
#define MAX_VBMETA_SIZE (8 * 1024)
|
|
|
|
|
|
//check SWPL-31296 for details
|
|
static int do_get_bootloader_status(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
bool printStat = false;
|
|
bool saveenv = false;
|
|
debugP("Initial value for argc=%d\n", argc);
|
|
while (argc > 1 && **(argv + 1) == '-') {
|
|
char *arg = *++argv;
|
|
|
|
--argc;
|
|
while (*++arg) {
|
|
switch (*arg) {
|
|
case 'p': /* print */
|
|
printStat = true;
|
|
break;
|
|
case 's': /* saveenv */
|
|
saveenv = true;
|
|
break;
|
|
default:
|
|
return CMD_RET_USAGE;
|
|
}
|
|
}
|
|
}
|
|
debugP("Final value for argc=%d\n", argc);
|
|
//1,forUpgrade_socType, cpu familyId
|
|
const cpu_id_t cpuid = get_cpu_id();
|
|
const int familyId = cpuid.family_id;
|
|
env_set_hex("forUpgrade_socType", familyId);
|
|
|
|
//2,forUpgrade_secureBoot
|
|
const bool secureboot = IS_FEAT_BOOT_VERIFY();
|
|
env_set("forUpgrade_secureBoot", secureboot ? "true" : "false");
|
|
|
|
//3,forUpgrade_robustOta
|
|
bool supportRobustOta = false;
|
|
switch (familyId) {
|
|
case 0x32://sc2
|
|
case 0x36://t7
|
|
case 0x37://s4
|
|
case 0x38://t3
|
|
case 0x3A://s4d
|
|
supportRobustOta = true;
|
|
break;
|
|
|
|
case MESON_CPU_MAJOR_ID_T5W:
|
|
case MESON_CPU_MAJOR_ID_TXHD2:
|
|
supportRobustOta = false;
|
|
break;
|
|
|
|
default:
|
|
{
|
|
if (familyId > 0x3A) {
|
|
supportRobustOta = true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
env_set("forUpgrade_robustOta", supportRobustOta ? "true" : "false");
|
|
|
|
//4,forUpgrade_flashType
|
|
const char* BootDevices[] = {
|
|
"BOOT_EMMC", "BOOT_SD",
|
|
"BOOT_NAND_NFTL", "BOOT_NAND_MTD",
|
|
"BOOT_SNAND", "BOOT_SNOR",
|
|
};
|
|
const char* bootDevice = "BOOT_NONE";
|
|
enum boot_type_e bootType = store_get_type();
|
|
int i = 0;
|
|
for (; i < ARRAY_SIZE(BootDevices); ++i) {
|
|
if ((1<<i) != bootType) continue;
|
|
bootDevice = BootDevices[i];
|
|
break;
|
|
}
|
|
env_set("forUpgrade_flashType", bootDevice);
|
|
|
|
//5,forUpgrade_bootloaderCopies, how many copies supported
|
|
int bootCopies = 1;
|
|
switch (bootType) {
|
|
case BOOT_EMMC: bootCopies = 3; break;
|
|
default:break;
|
|
}
|
|
env_set_ulong("forUpgrade_bootloaderCopies", bootCopies);
|
|
|
|
//6,forUpgrade_bootloaderIndex
|
|
//for emmc, 0/1/2 is user/boot0/boot1
|
|
const int bootCpyIndex = store_bootup_bootidx("bootloader");
|
|
env_set_ulong("forUpgrade_bootloaderIndex", bootCpyIndex);
|
|
|
|
//7,get first boot index, for defendkey
|
|
const int firstBootCpyIndex = store_boot_copy_start();
|
|
env_set_ulong("forUpgrade_1stBootIndex", firstBootCpyIndex);
|
|
|
|
if (env_get_ulong("loglevel", 10, 0) >= 9 && printStat)
|
|
run_command("printenv forUpgrade_socType forUpgrade_secureBoot "
|
|
" forUpgrade_robustOta forUpgrade_flashType forUpgrade_bootloaderCopies "
|
|
" forUpgrade_bootloaderIndex forUpgrade_1stBootIndex", 0);
|
|
|
|
//8,production mode for ver4 boot.img bootconfig
|
|
env_set_ulong("production_mode", CONFIG_IS_ENABLED(AML_PRODUCT_MODE));
|
|
if (printStat)
|
|
run_command("printenv production_mode", 0);
|
|
|
|
if (saveenv) {
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p forUpgrade_robustOta forUpgrade_bootloaderIndex", 0
|
|
);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
}
|
|
|
|
|
|
return CMD_RET_SUCCESS;
|
|
}
|
|
|
|
static void run_recovery_from_flash(void) {
|
|
env_set("dolby_status","0");
|
|
run_command("run init_display", 0);
|
|
run_command("run storeargs", 0);
|
|
run_command("get_rebootmode", 0);
|
|
run_command("if test ${reboot_mode} = quiescent; then "\
|
|
"setenv bootconfig ${bootconfig} androidboot.quiescent=1; fi;", 0);
|
|
run_command("if test ${reboot_mode} = recovery_quiescent; then "\
|
|
"setenv bootconfig ${bootconfig} androidboot.quiescent=1; fi;", 0);
|
|
run_command("run recovery_from_flash", 0);
|
|
}
|
|
|
|
static void run_recovery_from_cache(void) {
|
|
|
|
char *loadaddr_kernel = env_get("loadaddr_kernel");
|
|
if (loadaddr_kernel != NULL) {
|
|
env_set("loadaddr",loadaddr_kernel);
|
|
} else {
|
|
env_set("loadaddr","0x01080000");
|
|
}
|
|
env_set("dolby_status","0");
|
|
run_command("run bcb_cmd;", 0);
|
|
run_command("run init_display", 0);
|
|
run_command("run storeargs", 0);
|
|
run_command("get_rebootmode", 0);
|
|
|
|
run_command("if test ${reboot_mode} = quiescent; then "\
|
|
"setenv bootconfig ${bootconfig} androidboot.quiescent=1; fi;", 0);
|
|
run_command("if test ${reboot_mode} = recovery_quiescent; then "\
|
|
"setenv bootconfig ${bootconfig} androidboot.quiescent=1; fi;", 0);
|
|
run_command("if ext4load mmc 1:2 ${dtb_mem_addr} /recovery/dtb.img; then "\
|
|
"echo cache dtb.img loaded;"\
|
|
"else "\
|
|
"imgread dtb recovery ${dtb_mem_addr};"\
|
|
"fi;", 0);
|
|
|
|
run_command("if test ${reboot_vendor_boot} = true; then "\
|
|
"setenv vendor_boot_mode true; fi;", 0);
|
|
|
|
run_command("if test ${vendor_boot_mode} = true; then "\
|
|
"setenv bootargs ${bootargs} ${fs_type} aml_dt=${aml_dt} recovery_part=${recovery_part} recovery_offset=${recovery_offset};"\
|
|
"imgread kernel ${recovery_part} ${loadaddr} ${recovery_offset};"\
|
|
"avb memory recovery ${loadaddr};"\
|
|
"avb recovery 1;"\
|
|
"else "\
|
|
"if ext4load mmc 1:2 ${loadaddr} /recovery/recovery.img; then "\
|
|
"if avb memory recovery ${loadaddr}; then " \
|
|
"avb recovery 1;" \
|
|
"echo cache recovery.img loaded; fi;"\
|
|
"fi;" \
|
|
"fi;", 0);
|
|
|
|
env_set("check_result","recovery_succ");
|
|
env_set("recovery_mode", "true");
|
|
run_command("bootm ${loadaddr}", 0);
|
|
env_set("check_result","recovery_fail");
|
|
env_set("reboot_status","reboot_recovery");
|
|
run_command("saveenv", 0);
|
|
run_command("reboot", 0);//need reboot old bootloader
|
|
}
|
|
|
|
int write_bootloader_back(const char *bootloaderindex, int dstindex)
|
|
{
|
|
int iRet = 0;
|
|
int copy = 0;
|
|
int ret = -1;
|
|
unsigned char* buffer = NULL;
|
|
int capacity_boot = 0;
|
|
|
|
if (strcmp(bootloaderindex, "1") == 0) {
|
|
copy = 1;
|
|
} else if (strcmp(bootloaderindex, "2") == 0) {
|
|
copy = 2;
|
|
} else if (strcmp(bootloaderindex, "0") == 0) {
|
|
copy = 0;
|
|
}
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
struct mmc *mmc = NULL;
|
|
|
|
if (store_get_type() == BOOT_EMMC)
|
|
mmc = find_mmc_device(1);
|
|
|
|
if (mmc)
|
|
capacity_boot = mmc->capacity_boot;
|
|
#endif
|
|
|
|
printf("write_bootloader_back_capacity_boot: %x\n", capacity_boot);
|
|
|
|
buffer = (unsigned char *)malloc(capacity_boot);
|
|
if (!buffer)
|
|
{
|
|
printf("ERROR! fail to allocate memory ...\n");
|
|
goto exit;
|
|
}
|
|
memset(buffer, 0, capacity_boot);
|
|
iRet = store_boot_read("bootloader", copy, 0, buffer);
|
|
if (iRet) {
|
|
errorP("Fail read bootloader from rsv with sz\n");
|
|
goto exit;
|
|
}
|
|
iRet = store_boot_write("bootloader", dstindex, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to write bootloader\n");
|
|
goto exit;
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
|
|
exit:
|
|
if (buffer)
|
|
{
|
|
free(buffer);
|
|
//buffer = NULL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//bootloader write protect
|
|
static void bootloader_wp(void)
|
|
{
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
if (store_get_type() == BOOT_EMMC) {//emmc device
|
|
if (IS_FEAT_BOOT_VERIFY()) { //secure boot enable
|
|
if (BOOTLOADER_MODE_ADVANCE_INIT) { //new arch chip
|
|
env_set("bootloader_wp", "1");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void aml_recovery(void) {
|
|
char *mode = NULL;
|
|
char command[32];
|
|
char miscbuf[4096] = {0};
|
|
|
|
run_command("get_rebootmode", 0);
|
|
|
|
//get reboot_mode
|
|
mode = env_get("reboot_mode");
|
|
if (mode == NULL) {
|
|
wrnP("can not get reboot mode, so skip recovery check\n");
|
|
} else {
|
|
if ((!strcmp(mode, "factory_reset")) || (!strcmp(mode, "update"))) {
|
|
env_set("dolby_status","0");
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK
|
|
int ret = 0;
|
|
extern int boot_info_open_partition(char *miscbuf);
|
|
ret = boot_info_open_partition(miscbuf);
|
|
if (ret != 0) {
|
|
wrnP("open misc partition failed, so skip recovery check");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
//if run recovery, need disable dolby
|
|
memcpy(command, miscbuf, 32);
|
|
if (!memcmp(command, "boot-recovery", strlen("boot-recovery"))) {
|
|
env_set("dolby_status","0");
|
|
return;
|
|
}
|
|
}
|
|
|
|
void update_rollback(void)
|
|
{
|
|
char *slot = NULL;
|
|
int ret = -1;
|
|
int gpt_flag = -1;
|
|
char *rebootmode = env_get("reboot_mode");
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
struct mmc *mmc = NULL;
|
|
|
|
if (store_get_type() == BOOT_EMMC)
|
|
mmc = find_mmc_device(1);
|
|
|
|
if (mmc)
|
|
gpt_flag = aml_gpt_valid(mmc);
|
|
#endif
|
|
if (gpt_flag == 0)
|
|
ret = 0;
|
|
|
|
#if defined(CONFIG_EFUSE_OBJ_API) && defined(CONFIG_CMD_EFUSE)
|
|
run_command("efuse_obj get FEAT_DISABLE_EMMC_USER", 0);
|
|
|
|
//dis_user_flag = run_command("efuse_obj get FEAT_DISABLE_EMMC_USER", 0);
|
|
if (*efuse_field.data == 1)
|
|
ret = 0;
|
|
#endif//#ifdef CONFIG_EFUSE_OBJ_API
|
|
|
|
slot = env_get("slot-suffixes");
|
|
if (!slot) {
|
|
run_command("get_valid_slot", 0);
|
|
slot = env_get("slot-suffixes");
|
|
}
|
|
if (strcmp(slot, "0") == 0) {
|
|
if (ret != 0) {
|
|
wrnP("normal mode\n");
|
|
write_bootloader_back("2", 0);
|
|
env_set("expect_index", "0");
|
|
} else {
|
|
wrnP("gpt or disable user bootloader mode\n");
|
|
run_command("check_uboot_state 0", 0);
|
|
write_bootloader_back("2", 1);
|
|
env_set("expect_index", "1");
|
|
}
|
|
wrnP("back to slot b\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot b", 0);
|
|
} else if (strcmp(slot, "1") == 0) {
|
|
if (ret != 0) {
|
|
wrnP("normal mode\n");
|
|
write_bootloader_back("1", 0);
|
|
env_set("expect_index", "0");
|
|
} else {
|
|
wrnP("gpt or disable user bootloader mode\n");
|
|
run_command("check_uboot_state 1", 0);
|
|
write_bootloader_back("2", 1);
|
|
env_set("expect_index", "1");
|
|
}
|
|
wrnP("back to slot a\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot a", 0);
|
|
}
|
|
env_set("update_env", "1");
|
|
env_set("reboot_status", "reboot_next");
|
|
env_set("update_dts_gpt", "0");
|
|
env_set("write_boot", "0");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
static int write_bootloader_to_logical(void)
|
|
{
|
|
unsigned char *buffer = NULL;
|
|
int capacity_boot = 0x2000 * 512;
|
|
int iRet = 0;
|
|
char partname[32] = {0};
|
|
char back_partname[32] = {0};
|
|
char *slot_name = NULL;
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
struct mmc *mmc = NULL;
|
|
|
|
if (store_get_type() == BOOT_EMMC)
|
|
mmc = find_mmc_device(1);
|
|
|
|
if (mmc)
|
|
capacity_boot = mmc->capacity_boot;
|
|
#endif
|
|
|
|
printf("capacity_boot in write uboot to logical: 0x%x\n", capacity_boot);
|
|
buffer = (unsigned char *)malloc(capacity_boot);
|
|
if (!buffer) {
|
|
printf("ERROR! fail to allocate memory ...\n");
|
|
return -1;
|
|
}
|
|
memset(buffer, 0, capacity_boot);
|
|
|
|
slot_name = env_get("active_slot");
|
|
if (slot_name && (strcmp(slot_name, "_a") == 0)) {
|
|
strcpy((char *)partname, "bootloader_a");
|
|
strcpy((char *)back_partname, "bootloader_b");
|
|
} else if (slot_name && (strcmp(slot_name, "_b") == 0)) {
|
|
strcpy((char *)partname, "bootloader_b");
|
|
strcpy((char *)back_partname, "bootloader_a");
|
|
}
|
|
|
|
iRet = store_boot_read("bootloader", 1, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to read bootloader\n");
|
|
free(buffer);
|
|
return -1;
|
|
}
|
|
|
|
printf("write boot0 to %s\n", partname);
|
|
iRet = store_logic_write(partname, 0,
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, buffer);
|
|
if (iRet) {
|
|
errorP("Fail to write 0x%xB to part[%s] at offset 0\n",
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, partname);
|
|
free(buffer);
|
|
return -1;
|
|
}
|
|
|
|
iRet = store_boot_read("bootloader", 2, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to read boot1\n");
|
|
free(buffer);
|
|
return -1;
|
|
}
|
|
|
|
printf("write boot1 to %s\n", back_partname);
|
|
iRet = store_logic_write(back_partname, 0,
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, buffer);
|
|
if (iRet) {
|
|
errorP("Fail to write 0x%xB to part[%s] at offset 0\n",
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, back_partname);
|
|
free(buffer);
|
|
return -1;
|
|
}
|
|
|
|
free(buffer);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int write_bootloader(int i)
|
|
{
|
|
unsigned char *buffer = NULL;
|
|
int capacity_boot = 0x2000 * 512;
|
|
int iRet = 0;
|
|
char partname[32] = {0};
|
|
char *slot_name = NULL;
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
struct mmc *mmc = NULL;
|
|
|
|
if (store_get_type() == BOOT_EMMC)
|
|
mmc = find_mmc_device(1);
|
|
|
|
if (mmc)
|
|
capacity_boot = mmc->capacity_boot;
|
|
#endif
|
|
|
|
printf("capacity_boot: 0x%x\n", capacity_boot);
|
|
buffer = (unsigned char *)malloc(capacity_boot);
|
|
if (!buffer) {
|
|
printf("ERROR! fail to allocate memory ...\n");
|
|
return -1;
|
|
}
|
|
memset(buffer, 0, capacity_boot);
|
|
|
|
slot_name = env_get("active_slot");
|
|
if (slot_name && (strcmp(slot_name, "_a") == 0))
|
|
strcpy((char *)partname, "bootloader_a");
|
|
else if (slot_name && (strcmp(slot_name, "_b") == 0))
|
|
strcpy((char *)partname, "bootloader_b");
|
|
else
|
|
strcpy((char *)partname, "bootloader_up");
|
|
|
|
iRet = store_logic_read(partname, 0, BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, buffer);
|
|
if (iRet) {
|
|
errorP("Fail to read 0x%xB from part[%s] at offset 0\n",
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, partname);
|
|
free(buffer);
|
|
return -1;
|
|
}
|
|
|
|
iRet = store_boot_write("bootloader", i, BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, buffer);
|
|
if (iRet) {
|
|
printf("Failed to write boot0\n");
|
|
free(buffer);
|
|
return -1;
|
|
}
|
|
|
|
free(buffer);
|
|
return 0;
|
|
}
|
|
|
|
static int update_gpt(int flag)
|
|
{
|
|
int ret = 0;
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
unsigned char *buffer = NULL;
|
|
int capacity_boot = 0x2000 * 512;
|
|
int iRet = 0;
|
|
struct mmc *mmc = NULL;
|
|
struct blk_desc *dev_desc;
|
|
int write_gpt = 0;
|
|
int gpt_flag = -1;
|
|
|
|
if (store_get_type() == BOOT_EMMC)
|
|
mmc = find_mmc_device(1);
|
|
|
|
if (mmc)
|
|
gpt_flag = aml_gpt_valid(mmc);
|
|
|
|
if (mmc)
|
|
capacity_boot = mmc->capacity_boot;
|
|
|
|
printf("capacity_boot: 0x%x\n", capacity_boot);
|
|
printf("flag: %d\n", flag);
|
|
buffer = (unsigned char *)malloc(capacity_boot);
|
|
if (!buffer) {
|
|
printf("ERROR! fail to allocate memory ...\n");
|
|
return -1;
|
|
}
|
|
memset(buffer, 0, capacity_boot);
|
|
|
|
if (flag == 0) {
|
|
iRet = store_boot_read("bootloader", 1, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to read boot0\n");
|
|
ret = -1;
|
|
goto exit;
|
|
}
|
|
} else if (flag == 1 || flag == 2) {
|
|
iRet = store_boot_read("bootloader", 0, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to read bootloader\n");
|
|
ret = -1;
|
|
goto exit;
|
|
}
|
|
} else if (flag == 3) {
|
|
printf("null ab mode\n");
|
|
iRet = store_logic_read("bootloader_up", 0,
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET, buffer);
|
|
if (iRet) {
|
|
printf("Fail to read 0x%xB from bootloader_up\n",
|
|
BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET);
|
|
ret = -1;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
if (mmc) {
|
|
printf("try to read gpt data from bootloader.img\n");
|
|
int erase_flag = 0;
|
|
|
|
dev_desc = blk_get_dev("mmc", 1);
|
|
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
|
|
printf("invalid mmc device\n");
|
|
ret = -1;
|
|
goto exit;
|
|
}
|
|
|
|
if (is_valid_gpt_buf(dev_desc, buffer + GPT_OFFSET) &&
|
|
is_valid_gpt_buf(dev_desc, buffer + GPT2_OFFSET) &&
|
|
is_valid_gpt_buf(dev_desc, buffer + DTS_GPT_OFFSET)) {
|
|
printf("printf normal bootloader.img, no gpt partition table\n");
|
|
|
|
char *dts_flag = env_get("dts_to_gpt");
|
|
char *write_boot = env_get("write_boot");
|
|
|
|
if (write_boot && !strcmp(write_boot, "1")) {
|
|
if (dts_flag && (strcmp(dts_flag, "1") == 0)) {
|
|
printf("write dtb back when rollback\n");
|
|
erase_gpt_part_table(dev_desc);
|
|
if (run_command("imgread dtb ${boot_part} ${dtb_mem_addr}", 0)) {
|
|
printf("Fail in load dtb\n");
|
|
} else {
|
|
printf("write dtb back\n");
|
|
run_command("emmc dtb_write ${dtb_mem_addr} 0", 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
ret = -1;
|
|
goto exit;
|
|
} else {
|
|
if (!is_valid_gpt_buf(dev_desc, buffer + GPT_OFFSET)) {
|
|
erase_flag = check_gpt_change(dev_desc, buffer + GPT_OFFSET);
|
|
} else if (!is_valid_gpt_buf(dev_desc, buffer + DTS_GPT_OFFSET)) {
|
|
erase_flag = check_gpt_change(dev_desc, buffer + DTS_GPT_OFFSET);
|
|
} else if (!is_valid_gpt_buf(dev_desc, buffer + GPT2_OFFSET)) {
|
|
erase_flag = check_gpt_change(dev_desc, buffer + GPT2_OFFSET);
|
|
} else {
|
|
printf("printf normal bootloader.img, no gpt partition table\n");
|
|
}
|
|
if (erase_flag == 4 && has_boot_slot == 0) {
|
|
printf("null ab critical partition change, refused to upgrade\n");
|
|
ret = 5;
|
|
goto exit;
|
|
} else if (has_boot_slot == 1 && (erase_flag == 3 || erase_flag == 4)) {
|
|
printf("Important partition changes, refused to upgrade\n");
|
|
ret = 1;
|
|
goto exit;
|
|
} else if (erase_flag == 0) {
|
|
printf("partition doesn't change, needn't update\n");
|
|
ret = -1;
|
|
goto clean;
|
|
}
|
|
|
|
if (flag == 1 || flag == 2) {
|
|
printf("update from dts to gpt, erase first\n");
|
|
erase_gpt_part_table(dev_desc);
|
|
}
|
|
|
|
if (flag == 2) {
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
env_set("dts_to_gpt", "1");
|
|
run_command("update_env_part -p dts_to_gpt;", 0);
|
|
#else
|
|
run_command("defenv_reserve;setenv dts_to_gpt 1;saveenv;", 0);
|
|
#endif
|
|
}
|
|
|
|
run_command("store boot_erase bootloader 0;", 0);
|
|
|
|
if (!is_valid_gpt_buf(dev_desc, buffer + GPT_OFFSET)) {
|
|
write_gpt = write_mbr_and_gpt_partitions(dev_desc,
|
|
buffer + GPT_OFFSET);
|
|
} else if (!is_valid_gpt_buf(dev_desc, buffer + DTS_GPT_OFFSET)) {
|
|
write_gpt = write_mbr_and_gpt_partitions(dev_desc,
|
|
buffer + DTS_GPT_OFFSET);
|
|
} else if (!is_valid_gpt_buf(dev_desc, buffer + GPT2_OFFSET)) {
|
|
write_gpt = write_mbr_and_gpt_partitions(dev_desc,
|
|
buffer + GPT2_OFFSET);
|
|
} else {
|
|
printf("printf normal bootloader.img, no gpt partition table\n");
|
|
}
|
|
|
|
if (write_gpt) {
|
|
printf("%s: writing GPT partitions failed\n", __func__);
|
|
ret = 1;
|
|
goto exit;
|
|
}
|
|
|
|
if (mmc_device_init(mmc) != 0) {
|
|
printf(" update gpt partition table fail\n");
|
|
ret = 2;
|
|
goto exit;
|
|
}
|
|
|
|
if (erase_flag == 5) {
|
|
printf("userdata size change, adjust backup gpt\n");
|
|
ret = -1;
|
|
}
|
|
printf("%s: writing GPT partitions ok\n", __func__);
|
|
}
|
|
}
|
|
|
|
clean:
|
|
if (flag == 0) {
|
|
if (has_boot_slot == 1 && gpt_flag != 0)
|
|
write_bootloader_to_logical();
|
|
|
|
memset(buffer + GPT_OFFSET, 0, capacity_boot - GPT_OFFSET);
|
|
iRet = store_boot_write("bootloader", 1, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to write boot0\n");
|
|
ret = -1;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
if (has_boot_slot == 1 && (flag == 1 || flag == 2)) {
|
|
printf("update from dts to gpt, backup old bootloader\n");
|
|
char *slot = NULL;
|
|
|
|
slot = env_get("slot-suffixes");
|
|
if (!slot) {
|
|
run_command("get_valid_slot", 0);
|
|
slot = env_get("slot-suffixes");
|
|
}
|
|
if (strcmp(slot, "0") == 0) {
|
|
printf("active is a, b is old, don't need backup\n");
|
|
} else if (strcmp(slot, "1") == 0) {
|
|
printf("active is b, a is old, backup boot0 to boot1\n");
|
|
iRet = write_bootloader_back("1", 2);
|
|
if (iRet != 0) {
|
|
printf("Failed to write boot1\n");
|
|
ret = 3;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
iRet = store_boot_write("bootloader", 1, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to write boot0\n");
|
|
ret = 4;
|
|
goto exit;
|
|
}
|
|
|
|
if (has_boot_slot == 1 && gpt_flag != 0)
|
|
write_bootloader_to_logical();
|
|
|
|
memset(buffer + GPT_OFFSET, 0, capacity_boot - GPT_OFFSET);
|
|
iRet = store_boot_write("bootloader", 1, 0, buffer);
|
|
if (iRet) {
|
|
printf("Failed to write boot0\n");
|
|
ret = 4;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
if (buffer)
|
|
free(buffer);
|
|
|
|
if (mmc)
|
|
run_command("mmc dev 1 0;", 0);
|
|
|
|
if (mmc && ret > 0) {
|
|
if (ret == 1 || ret == 2 || ret == 3) {
|
|
printf("rollback\n");
|
|
update_rollback();
|
|
} else if (ret == 4) {
|
|
printf("write back boot0, rollback\n");
|
|
write_bootloader_back("2", 1);
|
|
update_rollback();
|
|
}
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
int recovery_update(void)
|
|
{
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
char bufcmd[64];
|
|
unsigned long long size = 0;
|
|
char *recovery_need_update = NULL;
|
|
struct partitions *partition = NULL;
|
|
//"ANDROID!"
|
|
const unsigned char imghead[] = { 0x41, 0x4e, 0x44, 0x52, 0x4f, 0x49, 0x44, 0x21 };
|
|
|
|
if (store_get_type() != BOOT_EMMC)
|
|
return 0;
|
|
|
|
//check recoverybak partition exist
|
|
partition = find_mmc_partition_by_name("recoverybak");
|
|
if (!partition) {
|
|
printf("can not find recoverybak, skip\n");
|
|
return 0;
|
|
}
|
|
|
|
//check if need update recovery from recoverybak
|
|
recovery_need_update = env_get("recovery_need_update");
|
|
if (!recovery_need_update || strcmp(recovery_need_update, "1"))
|
|
return 0;
|
|
|
|
//read recoverybak header data for check
|
|
sprintf(bufcmd, "store read $loadaddr recoverybak 0 0x%x", 16);
|
|
run_command(bufcmd, 0);
|
|
|
|
unsigned char *loadaddr = (unsigned char *)simple_strtoul(env_get("loadaddr"), NULL, 16);
|
|
|
|
//check recoverybak head is start "ANDROID!"
|
|
if (memcmp((void *)imghead, loadaddr, 8)) {
|
|
printf("not valid recovery image, skip update recovery\n");
|
|
return 0;
|
|
}
|
|
|
|
//write recoverybak data to recovery
|
|
while (size < partition->size) {
|
|
unsigned long long write_size = 0;
|
|
unsigned long long left_size = partition->size - size;
|
|
|
|
if (left_size > 10 * MIB_SIZE)
|
|
write_size = 10 * MIB_SIZE;
|
|
else
|
|
write_size = partition->size - size;
|
|
|
|
sprintf(bufcmd, "store read $loadaddr recoverybak 0x%llx 0x%llx", size, write_size);
|
|
run_command(bufcmd, 0);
|
|
sprintf(bufcmd, "store write $loadaddr recovery 0x%llx 0x%llx", size, write_size);
|
|
run_command(bufcmd, 0);
|
|
size += write_size;
|
|
}
|
|
|
|
//clean recovery_need_update to 0
|
|
env_set("recovery_need_update", "0");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p recovery_need_update;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int build_userdebug(void)
|
|
{
|
|
#ifdef CONFIG_AVB2
|
|
int i = 0;
|
|
int ret = 0;
|
|
char *vbmeta_slot = NULL;
|
|
int userdebug = 0;
|
|
char vbmeta_name[16] = {0};
|
|
char vbuf[MAX_VBMETA_SIZE] = {0};
|
|
//"userdebug" 0x75 0x73 0x65 0x72 0x64 0x65 0x62 0x75 0x67
|
|
const unsigned char buildtype[] = { 0x75, 0x73, 0x65, 0x72, 0x64, 0x65, 0x62, 0x75, 0x67 };
|
|
|
|
printf("avb2 enable, get user/userdebug from vbmeta partition.\n");
|
|
char *get_vbmeta_slot(void);
|
|
vbmeta_slot = get_vbmeta_slot();
|
|
if (has_boot_slot == 0)
|
|
strcpy(vbmeta_name, "vbmeta");
|
|
else
|
|
sprintf(vbmeta_name, "vbmeta%s", vbmeta_slot);
|
|
|
|
ret = store_read(vbmeta_name, 0, MAX_VBMETA_SIZE, vbuf);
|
|
if (ret) {
|
|
printf("store read %s failed, skip!\n", vbmeta_name);
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < MAX_VBMETA_SIZE - 10; i++) {
|
|
if (vbuf[i] == 0x75) {
|
|
if (!memcmp(vbuf + i, buildtype, 9)) {
|
|
printf("find userdebug flag\n");
|
|
userdebug = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return userdebug;
|
|
|
|
#else
|
|
printf("avb2 disable, skip.\n");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
static int do_secureboot_check(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) {
|
|
int match_flag = 0;
|
|
char *rebootstatus = NULL;
|
|
char *checkresult = NULL;
|
|
char *bootloaderindex = NULL;
|
|
char *expect_index = NULL;
|
|
char *robustota = NULL;
|
|
char *update_env = NULL;
|
|
char *rebootmode = NULL;
|
|
int gpt_flag = -1;
|
|
int ret = -1;
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
struct mmc *mmc = NULL;
|
|
//int capacity_boot = 0;
|
|
|
|
if (store_get_type() == BOOT_EMMC)
|
|
mmc = find_mmc_device(1);
|
|
#endif
|
|
recovery_update();
|
|
|
|
bootloader_wp();
|
|
|
|
build_userdebug();
|
|
|
|
//set default env before check
|
|
env_set("recovery_mode", "false");
|
|
|
|
//if recovery mode, need disable dv, if factoryreset, need default uboot env
|
|
aml_recovery();
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
if (mmc)
|
|
gpt_flag = aml_gpt_valid(mmc);
|
|
#endif
|
|
if (gpt_flag == 0)
|
|
ret = 0;
|
|
|
|
#if defined(CONFIG_EFUSE_OBJ_API) && defined(CONFIG_CMD_EFUSE)
|
|
run_command("efuse_obj get FEAT_DISABLE_EMMC_USER", 0);
|
|
|
|
if (*efuse_field.data == 1) {
|
|
wrnP("efuse_field.data == 1\n");
|
|
ret = 0;
|
|
env_set("nocs_mode", "true");
|
|
} else {
|
|
wrnP("efuse_field.data != 1\n");
|
|
env_set("nocs_mode", "false");
|
|
}
|
|
#endif//#ifdef CONFIG_EFUSE_OBJ_API
|
|
|
|
run_command("get_rebootmode", 0);
|
|
rebootmode = env_get("reboot_mode");
|
|
if (!rebootmode) {
|
|
wrnP("can not get reboot mode, so skip secure check\n");
|
|
return -1;
|
|
}
|
|
printf("rebootmode is %s\n", rebootmode);
|
|
if (rebootmode && (strcmp(rebootmode, "rescueparty") == 0)) {
|
|
printf("rebootmode is rescueparty, need rollback\n");
|
|
env_set("rollback_reason", "rescueparty");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p rollback_reason;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
char *slot;
|
|
|
|
#ifdef CONFIG_FASTBOOT
|
|
struct misc_virtual_ab_message message;
|
|
|
|
set_mergestatus_cancel(&message);
|
|
#endif
|
|
|
|
slot = env_get("slot-suffixes");
|
|
if (!slot) {
|
|
run_command("get_valid_slot", 0);
|
|
slot = env_get("slot-suffixes");
|
|
}
|
|
if (strcmp(slot, "0") == 0) {
|
|
if (ret != 0) {
|
|
wrnP("normal mode\n");
|
|
write_bootloader_back("2", 0);
|
|
env_set("expect_index", "0");
|
|
} else {
|
|
wrnP("gpt or disable user bootloader mode\n");
|
|
write_bootloader_back("2", 1);
|
|
env_set("expect_index", "1");
|
|
}
|
|
wrnP("back to slot b\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot b", 0);
|
|
} else if (strcmp(slot, "1") == 0) {
|
|
if (ret != 0) {
|
|
wrnP("normal mode\n");
|
|
write_bootloader_back("1", 0);
|
|
env_set("expect_index", "0");
|
|
} else {
|
|
wrnP("gpt or disable user bootloader mode\n");
|
|
write_bootloader_back("2", 1);
|
|
env_set("expect_index", "1");
|
|
}
|
|
wrnP("back to slot a\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot a", 0);
|
|
}
|
|
|
|
env_set("update_env", "1");
|
|
env_set("reboot_status", "reboot_next");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
|
|
char *recovery_check = env_get("recovery_check_part");
|
|
int update_flag = -1;
|
|
int rc = 0;
|
|
char *recovery_prepare = env_get("recovery_prepare_ok");
|
|
|
|
if (recovery_prepare && !strcmp(recovery_prepare, "1")) {
|
|
if (has_boot_slot == 0 && recovery_check &&
|
|
(!strcmp(recovery_check, "1") || !strcmp(recovery_check, "4"))) {
|
|
printf("non ab for kernel 5.15, check part table\n");
|
|
if (!strcmp(recovery_check, "1")) {
|
|
printf("try write boot1\n");
|
|
rc = write_bootloader(1);
|
|
if (rc) {
|
|
printf("write boot1 fail, OTA error\n");
|
|
env_set("recovery_check_part", "3");
|
|
} else {
|
|
printf("check & update part\n");
|
|
update_flag = update_gpt(3);
|
|
}
|
|
} else if (!strcmp(recovery_check, "4")) {
|
|
printf("check & update part\n");
|
|
update_flag = update_gpt(1);
|
|
}
|
|
|
|
run_command("defenv_reserv; saveenv;", 0);
|
|
run_command("run bcb_cmd", 0);
|
|
|
|
if (update_flag < 1) {
|
|
printf("check & update part ok......\n");
|
|
env_set("recovery_check_part", "2");
|
|
printf("boot from boot0\n");
|
|
env_set("reboot_status", "reboot_next");
|
|
env_set("expect_index", "1");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p reboot_status;", 0);
|
|
run_command("update_env_part -p expect_index;", 0);
|
|
#endif
|
|
} else {
|
|
printf("check & update part error\n");
|
|
if (!strcmp(recovery_check, "1")) {
|
|
printf("write boot0 back\n");
|
|
write_bootloader_back("2", 1);
|
|
} else if (!strcmp(recovery_check, "4")) {
|
|
printf("write bootloader back\n");
|
|
write_bootloader_back("2", 1);
|
|
write_bootloader_back("2", 0);
|
|
}
|
|
env_set("recovery_check_part", "3");
|
|
env_set("upgrade_step", "4");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p upgrade_step;", 0);
|
|
#endif
|
|
}
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p recovery_check_part;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
|
|
if (has_boot_slot == 0 && recovery_check &&
|
|
(!strcmp(recovery_check, "3"))) {
|
|
printf("check part error, run_recovery_from_flash\n");
|
|
run_recovery_from_flash();
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (has_boot_slot == 0 && recovery_check &&
|
|
!strcmp(recovery_check, "4")) {
|
|
printf("back to old bootloader\n");
|
|
write_bootloader_back("2", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
}
|
|
|
|
char *write_boot = env_get("write_boot");
|
|
|
|
if (has_boot_slot == 0 && write_boot && (!strcmp(write_boot, "1"))) {
|
|
printf("non ab for kernel 5.15 update bootloader\n");
|
|
write_bootloader(1);
|
|
write_bootloader(2);
|
|
env_set("write_boot", "0");
|
|
env_set("upgrade_step", "1");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
|
|
//check_result init
|
|
checkresult = env_get("check_result");
|
|
if (checkresult == NULL) {
|
|
env_set("check_result","succ");
|
|
}
|
|
|
|
//reboot_status init
|
|
rebootstatus = env_get("reboot_status");
|
|
if (rebootstatus == NULL) {
|
|
env_set("reboot_status","reboot_init");
|
|
rebootstatus = env_get("reboot_status");
|
|
}
|
|
|
|
if (rebootstatus == NULL) {
|
|
printf("rebootstatus is NULL, skip check\n");
|
|
return -1;
|
|
}
|
|
|
|
//check reboot_end
|
|
if (!strcmp(rebootstatus, "reboot_end")) {
|
|
env_set("reboot_status","reboot_init");
|
|
run_command("saveenv", 0);
|
|
}
|
|
|
|
//get boot status
|
|
run_command("amlbootsta -p -s", 0);
|
|
|
|
if (has_boot_slot == 0) {
|
|
//get forUpgrade_robustOta and check if support robustota
|
|
robustota = env_get("forUpgrade_robustOta");
|
|
if (!robustota || !strcmp(robustota, "false"))
|
|
return -1;
|
|
}
|
|
|
|
//get bootloader index
|
|
bootloaderindex = env_get("forUpgrade_bootloaderIndex");
|
|
if (bootloaderindex == NULL) {
|
|
wrnP("can not get bootloader index, so skip secure check\n");
|
|
return -1;
|
|
}
|
|
|
|
char *update_dts_gpt = NULL;
|
|
|
|
if (write_boot && !strcmp(write_boot, "1")) {
|
|
printf("need to write boot0\n");
|
|
run_command("check_uboot_state boot1", 0);
|
|
rc = write_bootloader(1);
|
|
if (rc) {
|
|
printf("write boot0 fail, need to rollback!\n");
|
|
env_set("rollback_reason", "boot0_update_fail");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p rollback_reason;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
update_rollback();
|
|
} else {
|
|
update_gpt(0);
|
|
printf("write boot0 success, need to reset!\n");
|
|
env_set("write_boot", "0");
|
|
env_set("reboot_status", "reboot_next");
|
|
env_set("expect_index", "1");
|
|
env_set("update_env", "1");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
}
|
|
|
|
update_dts_gpt = env_get("update_dts_gpt");
|
|
|
|
if (has_boot_slot == 1) {
|
|
if (rc == 0 && update_dts_gpt && !strcmp(update_dts_gpt, "1")) {
|
|
printf("update from dts to gpt\n");
|
|
update_flag = update_gpt(1);
|
|
if (update_flag != -1) {
|
|
env_set("update_dts_gpt", "0");
|
|
env_set("dts_to_gpt", "1");
|
|
env_set("reboot_status", "reboot_next");
|
|
env_set("expect_index", "1");
|
|
env_set("update_env", "1");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
} else {
|
|
printf("rebootstatus is %s\n", rebootstatus);
|
|
if (rc == 0 && !strcmp(rebootstatus, "reboot_next")) {
|
|
printf("update gpt\n");
|
|
update_flag = update_gpt(0);
|
|
env_set("update_gpt", "0");
|
|
strcpy(write_boot, "0");
|
|
env_set("write_boot", "0");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p update_gpt;", 0);
|
|
run_command("update_env_part -p write_boot;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
if (update_flag != -1) {
|
|
env_set("expect_index", "1");
|
|
if (gpt_flag != 0)
|
|
env_set("dts_to_gpt", "1");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p expect_index;", 0);
|
|
if (gpt_flag != 0)
|
|
run_command("update_env_part -p dts_to_gpt;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
#ifdef CONFIG_CMD_BOOTCTOL_VAB
|
|
if (mmc && is_android_image() && (!strcmp(rebootstatus, "reboot_next"))) {
|
|
struct blk_desc *dev_desc = mmc_get_blk_desc(mmc);
|
|
|
|
if (dev_desc && !strcmp(bootloaderindex, "0")) {
|
|
printf("try to read gpt data from bootloader.img\n");
|
|
update_flag = update_gpt(2);
|
|
if (update_flag != -1) {
|
|
printf("reset......\n");
|
|
env_set("reboot_status", "reboot_next");
|
|
env_set("expect_index", "1");
|
|
env_set("update_env", "1");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p reboot_status;", 0);
|
|
run_command("update_env_part -p expect_index;", 0);
|
|
run_command("update_env_part -p update_env;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//unsupport update dt in boothal, update dt in uboot
|
|
if (gpt_flag != 0 && !strcmp(rebootstatus, "reboot_next")) {
|
|
printf("dts partition table mode, check partition changes\n");
|
|
run_command("update_dt;", 0);
|
|
}
|
|
|
|
char *fastboot_step = env_get("fastboot_step");
|
|
|
|
if (mmc && fastboot_step && (strcmp(fastboot_step, "1") == 0)) {
|
|
printf("reboot to new bootloader burned by fastboot\n");
|
|
env_set("update_env", "1");
|
|
env_set("fastboot_step", "2");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "fastboot") == 0))
|
|
run_command("reboot next,bootloader", 0);
|
|
else
|
|
run_command("reboot next", 0);
|
|
}
|
|
if (mmc && fastboot_step &&
|
|
(strcmp(fastboot_step, "2") == 0 ||
|
|
strcmp(fastboot_step, "3") == 0)) {
|
|
struct blk_desc *dev_desc = mmc_get_blk_desc(mmc);
|
|
|
|
if (dev_desc && ((ret == 0 && !strcmp(bootloaderindex, "1")) ||
|
|
(ret != 0 && !strcmp(bootloaderindex, "0")))) {
|
|
printf("new bootloader error, please fastboot to another one\n");
|
|
env_set("fastboot_step", "3");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p fastboot_step;", 0);
|
|
#else
|
|
run_command("defenv_reserve;setenv fastboot_step 0;saveenv;", 0);
|
|
#endif
|
|
run_command("run enter_fastboot", 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//no secure check need
|
|
if (!strcmp(rebootstatus, "reboot_init")) {
|
|
printf("rebootstatus is reboot_init, skip check\n");
|
|
return -1;
|
|
}
|
|
|
|
//get expect index
|
|
expect_index = env_get("expect_index");
|
|
if (expect_index == NULL) {
|
|
wrnP("can not get expect index, so skip secure check\n");
|
|
return -1;
|
|
}
|
|
|
|
wrnP("expect_index is : %s\n", expect_index);
|
|
|
|
match_flag = strcmp(bootloaderindex, expect_index);
|
|
|
|
//ignore reboot next check if power off during reboot next to finish
|
|
if (rebootmode && (strcmp(rebootmode, "cold_boot") == 0)) {
|
|
if (!strcmp(rebootstatus, "reboot_finish")) {
|
|
match_flag = 0;
|
|
}
|
|
}
|
|
|
|
//first reboot, command from recovery, need reboot next
|
|
if (!strcmp(rebootstatus,"reboot_next")) {
|
|
wrnP("--secure check reboot_next---\n");
|
|
//bootloader index, expect == current, no need reboot next
|
|
if (match_flag == 0) {
|
|
wrnP("current index is expect, no need reboot next, run cache recovery\n");
|
|
env_set("reboot_status", "reboot_init");
|
|
#if CONFIG_IS_ENABLED(AML_UPDATE_ENV)
|
|
run_command("update_env_part -p reboot_status;", 0);
|
|
#else
|
|
run_command("saveenv", 0);
|
|
#endif
|
|
if (has_boot_slot == 1) {
|
|
wrnP("ab mode\n");
|
|
} else {
|
|
run_recovery_from_cache();
|
|
return 0;
|
|
}
|
|
} else {
|
|
wrnP("now ready start reboot next\n");
|
|
if (has_boot_slot == 1) {
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
if (mmc != NULL)
|
|
gpt_flag = aml_gpt_valid(mmc);
|
|
#endif
|
|
if (gpt_flag == 0)
|
|
ret = 0;
|
|
|
|
#if defined(CONFIG_EFUSE_OBJ_API) && defined(CONFIG_CMD_EFUSE)
|
|
run_command("efuse_obj get FEAT_DISABLE_EMMC_USER", 0);
|
|
|
|
if (*efuse_field.data == 1)
|
|
ret = 0;
|
|
#endif//#ifdef CONFIG_EFUSE_OBJ_API
|
|
if (ret == 0) {
|
|
wrnP("gpt or disable user bootloader mode, write boot1 to boot0\n");
|
|
write_bootloader_back("2", 1);
|
|
#ifdef CONFIG_FASTBOOT
|
|
struct misc_virtual_ab_message message;
|
|
|
|
set_mergestatus_cancel(&message);
|
|
#endif
|
|
char *slot;
|
|
|
|
slot = env_get("slot-suffixes");
|
|
if (!slot) {
|
|
run_command("get_valid_slot", 0);
|
|
slot = env_get("slot-suffixes");
|
|
}
|
|
if (strcmp(slot, "0") == 0) {
|
|
wrnP("back to slot b\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot b", 0);
|
|
} else if (strcmp(slot, "1") == 0) {
|
|
wrnP("back to slot a\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot a", 0);
|
|
}
|
|
env_set("expect_index", "1");
|
|
} else {
|
|
write_bootloader_back(bootloaderindex, 0);
|
|
#ifdef CONFIG_FASTBOOT
|
|
struct misc_virtual_ab_message message;
|
|
set_mergestatus_cancel(&message);
|
|
#endif
|
|
if (strcmp(bootloaderindex, "1") == 0) {
|
|
wrnP("back to slot a\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot a", 0);
|
|
} else if (strcmp(bootloaderindex, "2") == 0) {
|
|
wrnP("back to slot b\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot b", 0);
|
|
}
|
|
env_set("expect_index", "0");
|
|
}
|
|
|
|
env_set("update_env", "1");
|
|
env_set("reboot_status", "reboot_next");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
} else {
|
|
env_set("reboot_status","reboot_finish");
|
|
run_command("saveenv", 0);
|
|
run_command("get_rebootmode", 0);
|
|
run_command("if test ${reboot_mode} = quiescent; then reboot next,quiescent; else reboot next; fi;", 0);
|
|
}
|
|
return 0;
|
|
}
|
|
} else if (!strcmp(rebootstatus,"reboot_finish")) {//second reboot, reboot next from uboot
|
|
wrnP("--secure check reboot_finish---\n");
|
|
env_set("reboot_status","reboot_end");
|
|
run_command("saveenv", 0);
|
|
|
|
if (match_flag == 0) {
|
|
wrnP("reboot next succ, bootloader secure check pass......\n");
|
|
if (has_boot_slot == 1) {
|
|
printf("ab mode, default all uboot env\n");
|
|
update_env = env_get("update_env");
|
|
if (!update_env) {
|
|
errorP("can not get update_env\n");
|
|
return -1;
|
|
}
|
|
if (strcmp(update_env, "1") == 0) {
|
|
printf("ab mode, default all uboot env\n");
|
|
run_command("defenv_reserv;saveenv;", 0);
|
|
run_command("run bcb_cmd", 0);
|
|
env_set("update_env","0");
|
|
|
|
if (strcmp(bootloaderindex, "2") == 0) {
|
|
wrnP("rom always boot as boot0--> boot1\n");
|
|
wrnP("So if boot1 is ok, write it to boot0\n");
|
|
run_command("copy_slot_bootable 2 1", 0);
|
|
}
|
|
run_command("saveenv", 0);
|
|
}
|
|
} else {
|
|
run_recovery_from_cache();
|
|
return 0;
|
|
}
|
|
} else {
|
|
//bootloader check failed, run recovery show error
|
|
wrnP("reboot next fail, bootloader secure check fail(curr:%s, expect:%s)......\n",bootloaderindex, expect_index);
|
|
env_set("check_result","bootloader_fail");
|
|
run_command("saveenv", 0);
|
|
if (has_boot_slot == 1) {
|
|
wrnP("ab mode\n");
|
|
#ifdef CONFIG_FASTBOOT
|
|
struct misc_virtual_ab_message message;
|
|
set_mergestatus_cancel(&message);
|
|
#endif
|
|
if (strcmp(bootloaderindex, "1") == 0) {
|
|
wrnP("back to slot a\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot a", 0);
|
|
} else if (strcmp(bootloaderindex, "2") == 0) {
|
|
wrnP("back to slot b\n");
|
|
run_command("set_roll_flag 1", 0);
|
|
run_command("set_active_slot b", 0);
|
|
}
|
|
|
|
#ifdef CONFIG_MMC_MESON_GX
|
|
if (mmc != NULL)
|
|
gpt_flag = aml_gpt_valid(mmc);
|
|
#endif
|
|
|
|
if (gpt_flag == 0)
|
|
ret = 0;
|
|
|
|
#if defined(CONFIG_EFUSE_OBJ_API) && defined(CONFIG_CMD_EFUSE)
|
|
run_command("efuse_obj get FEAT_DISABLE_EMMC_USER", 0);
|
|
|
|
if (*efuse_field.data == 1)
|
|
ret = 0;
|
|
#endif//#ifdef CONFIG_EFUSE_OBJ_API
|
|
|
|
if (ret == 0) {
|
|
wrnP("gpt or disable user bootloader mode\n");
|
|
env_set("update_env","0");
|
|
env_set("reboot_status","reboot_init");
|
|
run_command("saveenv", 0);
|
|
} else {
|
|
write_bootloader_back(bootloaderindex, 0);
|
|
env_set("update_env","1");
|
|
env_set("reboot_status","reboot_next");
|
|
env_set("expect_index","0");
|
|
run_command("saveenv", 0);
|
|
if (rebootmode && (strcmp(rebootmode, "quiescent") == 0))
|
|
run_command("reboot quiescent", 0);
|
|
else
|
|
run_command("reboot", 0);
|
|
}
|
|
|
|
} else {
|
|
run_recovery_from_flash();
|
|
return 0;
|
|
}
|
|
}
|
|
} else if (!strcmp(rebootstatus,"reboot_recovery")) {
|
|
//recovery check failed, run recovery show error
|
|
wrnP("--secure check reboot_recovery---\n");
|
|
env_set("reboot_status","reboot_end");
|
|
run_command("saveenv", 0);
|
|
run_recovery_from_flash();
|
|
return 0;
|
|
} else {
|
|
env_set("check_result","succ");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//usb_burn check for env and display
|
|
static void factory_usb_burn_status_check(void)
|
|
{
|
|
if (env_get_hex("usbDiskNewBoot", 0) && env_get_hex("usbDiskBootCpy", 0xff) != 0xff) {
|
|
const int want_cpy = env_get_ulong("usbDiskBootCpy", 10, 0xff);
|
|
const int boot_cpy = store_bootup_bootidx("bootloader");
|
|
|
|
if (want_cpy != boot_cpy) {
|
|
pr_err("Fail check boot index, want %d but %d\n", want_cpy, boot_cpy);
|
|
env_set_ulong("usbDiskChkOk", 0);
|
|
//delete usbDiskBootCpy to avoid always enter check
|
|
run_command("env set usbDiskBootCpy", 0);
|
|
run_command("env set usbDiskNewBoot", 0);
|
|
run_command("env default preboot; saveenv", 0);
|
|
printf("USB_BURN img bootloader cannot bootup, so END upgrade\n");
|
|
return;
|
|
}
|
|
|
|
printf("okay check img bootloader for usb_burn\n");
|
|
printf("update env for usb_burn\n");
|
|
run_command("printenv usbDiskNewBoot sdcburncfg usbDiskUpgrade preboot", 0);
|
|
run_command("defenv_reserve usbDiskNewBoot sdcburncfg usbDiskUpgrade preboot", 0);
|
|
run_command("printenv usbDiskNewBoot sdcburncfg usbDiskUpgrade preboot", 0);
|
|
run_command("env set usbDiskBootCpy ff", 0);
|
|
run_command("env set usbDiskChkOk 1;saveenv", 0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static int do_update_uboot_env(cmd_tbl_t *cmdtp,
|
|
int flag,
|
|
int argc,
|
|
char * const argv[])
|
|
{
|
|
const int write_boot = env_get_ulong("write_boot", 10, 0);
|
|
const int update_dts_gpt = env_get_ulong("update_dts_gpt", 10, 0);
|
|
|
|
//skip update env if need update bootloader
|
|
if (write_boot || update_dts_gpt) {
|
|
run_command("echo write_boot ${write_boot}, update_dts_gpt ${update_dts_gpt}", 0);
|
|
return 0;
|
|
}
|
|
|
|
//default uboot env need before anyone use it
|
|
//after factory reset
|
|
if (env_get("default_env")) {
|
|
printf("factory reset, need default all uboot env.\n");
|
|
run_command("defenv_reserv; setenv upgrade_step 2; saveenv;", 0);
|
|
}
|
|
|
|
//after ab update
|
|
char *update_env = env_get("update_env");
|
|
|
|
if (update_env && (strcmp(update_env, "1") == 0)) {
|
|
printf("ab mode, default all uboot env\n");
|
|
run_command("defenv_reserv; setenv upgrade_step 2; saveenv;", 0);
|
|
}
|
|
|
|
//after recovery update
|
|
char *upgrade_step = env_get("upgrade_step");
|
|
|
|
if (upgrade_step && (strcmp(upgrade_step, "1") == 0)) {
|
|
printf("after recovery update, need update uboot env\n");
|
|
run_command("defenv_reserv; setenv upgrade_step 2; saveenv;", 0);
|
|
}
|
|
|
|
factory_usb_burn_status_check();
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_BOOT_CMD_COMPLETE(
|
|
amlbootsta, 3, 0, do_get_bootloader_status,
|
|
"get bootloader status in env",
|
|
"[-p] print bootloader status\n"
|
|
"[-s] saveenv after generate bootloader status\n",
|
|
var_complete
|
|
);
|
|
|
|
U_BOOT_CMD_COMPLETE(
|
|
amlsecurecheck, 1, 0, do_secureboot_check,
|
|
"try bootloader/dtb/recovery secure check",
|
|
""
|
|
"",
|
|
var_complete
|
|
);
|
|
|
|
U_BOOT_CMD(aml_update_env,
|
|
1, 0, do_update_uboot_env,
|
|
"aml_update_env",
|
|
"\nThis command will update uboot env\n"
|
|
"So you can execute command: aml_update_env"
|
|
);
|
|
|
|
|