BPI-CM9-Linux/aml-comp/uboot/bl33/v2015/common/cmd_bootctl_avb.c

/*
* Copyright (C) 2017 Amlogic, Inc. All rights reserved.
* *
This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
* *
This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
* *
You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
* *
Description:
*/

#include <common.h>
#include <command.h>
#include <environment.h>
#include <malloc.h>
#include <asm/byteorder.h>
#include <config.h>
#include <asm/arch/io.h>
#include <partition_table.h>
#include <libavb.h>
#include <version.h>
#include <fb_mmc.h>
#include <mmc.h>
#include <amlogic/aml_mmc.h>
#include <u-boot/sha1.h>

#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK

// Spaces used by misc partition are as below:
// 0   - 2K	For bootloader_message
// 2K  - 16K	Used by Vendor's bootloader (the 2K - 4K range may be optionally used
//				as bootloader_message_ab struct)
// 16K - 32K	Used by uncrypt and recovery to store wipe_package for A/B devices
// 32K - 64K	System space, used for miscellanious AOSP features. See below.
// Note that these offsets are admitted by bootloader,recovery and uncrypt, so they
// are not configurable without changing all of them.
#define BOOTLOADER_MESSAGE_OFFSET_IN_MISC 0
#define VENDOR_SPACE_OFFSET_IN_MISC 2 * 1024
#define WIPE_PACKAGE_OFFSET_IN_MISC 16 * 1024
#define SYSTEM_SPACE_OFFSET_IN_MISC 32 * 1024
#define SYSTEM_SPACE_SIZE_IN_MISC 32 * 1024
#define BOOTLOADER_OFFSET		512
#define BOOTLOADER_MAX_SIZE		(4 * 1024 * 1024)


extern int store_read_ops(
	unsigned char *partition_name,
	unsigned char *buf, uint64_t off, uint64_t size);
extern int store_write_ops(
	unsigned char *partition_name,
	unsigned char *buf, uint64_t off, uint64_t size);

#define AB_METADATA_MISC_PARTITION_OFFSET 2048

#define MISCBUF_SIZE  2080

/* Bootloader Message (2-KiB)
 *
 * This structure describes the content of a block in flash
 * that is used for recovery and the bootloader to talk to
 * each other.
 *
 * The command field is updated by linux when it wants to
 * reboot into recovery or to update radio or bootloader firmware.
 * It is also updated by the bootloader when firmware update
 * is complete (to boot into recovery for any final cleanup)
 *
 * The status field was used by the bootloader after the completion
 * of an "update-radio" or "update-hboot" command, which has been
 * deprecated since Froyo.
 *
 * The recovery field is only written by linux and used
 * for the system to send a message to recovery or the
 * other way around.
 *
 * The stage field is written by packages which restart themselves
 * multiple times, so that the UI can reflect which invocation of the
 * package it is.  If the value is of the format "#/#" (eg, "1/3"),
 * the UI will add a simple indicator of that status.
 *
 * We used to have slot_suffix field for A/B boot control metadata in
 * this struct, which gets unintentionally cleared by recovery or
 * uncrypt. Move it into struct bootloader_message_ab to avoid the
 * issue.
 */
struct bootloader_message {
	char command[32];
	char status[32];
	char recovery[768];

	// The 'recovery' field used to be 1024 bytes.	It has only ever
	// been used to store the recovery command line, so 768 bytes
	// should be plenty.  We carve off the last 256 bytes to store the
	// stage string (for multistage packages) and possible future
	// expansion.
	char stage[32];

	// The 'reserved' field used to be 224 bytes when it was initially
	// carved off from the 1024-byte recovery field. Bump it up to
	// 1184-byte so that the entire bootloader_message struct rounds up
	// to 2048-byte.
	char reserved[1184];
};

/**
 * The A/B-specific bootloader message structure (4-KiB).
 *
 * We separate A/B boot control metadata from the regular bootloader
 * message struct and keep it here. Everything that's A/B-specific
 * stays after struct bootloader_message, which should be managed by
 * the A/B-bootloader or boot control HAL.
 *
 * The slot_suffix field is used for A/B implementations where the
 * bootloader does not set the androidboot.ro.boot.slot_suffix kernel
 * commandline parameter. This is used by fs_mgr to mount /system and
 * other partitions with the slotselect flag set in fstab. A/B
 * implementations are free to use all 32 bytes and may store private
 * data past the first NUL-byte in this field. It is encouraged, but
 * not mandatory, to use 'struct bootloader_control' described below.
 *
 * The update_channel field is used to store the Omaha update channel
 * if update_engine is compiled with Omaha support.
 */
struct bootloader_message_ab {
	struct bootloader_message message;
	char slot_suffix[32];
	char update_channel[128];

	// Round up the entire struct to 4096-byte.
	char reserved[1888];
};

#define BOOT_CTRL_MAGIC   0x42414342 /* Bootloader Control AB */
#define BOOT_CTRL_VERSION 1

typedef struct slot_metadata {
	// Slot priority with 15 meaning highest priority, 1 lowest
	// priority and 0 the slot is unbootable.
	uint8_t priority : 4;
	// Number of times left attempting to boot this slot.
	uint8_t tries_remaining : 3;
	// 1 if this slot has booted successfully, 0 otherwise.
	uint8_t successful_boot : 1;
	// 1 if this slot is corrupted from a dm-verity corruption, 0
	// otherwise.
	uint8_t verity_corrupted : 1;
	// Reserved for further use.
	uint8_t reserved : 7;
} slot_metadata;

/* Bootloader Control AB
 *
 * This struct can be used to manage A/B metadata. It is designed to
 * be put in the 'slot_suffix' field of the 'bootloader_message'
 * structure described above. It is encouraged to use the
 * 'bootloader_control' structure to store the A/B metadata, but not
 * mandatory.
 */
typedef struct bootloader_control {
	// NUL terminated active slot suffix.
	char slot_suffix[4];
	// Bootloader Control AB magic number (see BOOT_CTRL_MAGIC).
	u32 magic;
	// Version of struct being used (see BOOT_CTRL_VERSION).
	u8 version;
	// Number of slots being managed.
	u8 nb_slot : 3;
	// Number of times left attempting to boot recovery.
	u8 recovery_tries_remaining : 3;
	// Status of any pending snapshot merge of dynamic partitions.
	u8 merge_status : 3;
	// Ensure 4-bytes alignment for slot_info field.
	u8 roll_flag;
	// Per-slot information.  Up to 4 slots.
	struct slot_metadata slot_info[4];
	// Reserved for further use.
	u8 reserved1[8];
	// CRC32 of all 28 bytes preceding this field (little endian
	// format).
	u32 crc32_le;
} bootloader_control;

#define MISC_VIRTUAL_AB_MESSAGE_VERSION 2
#define MISC_VIRTUAL_AB_MAGIC_HEADER 0x56740AB0

unsigned int kDefaultBootAttempts = 4;

/* Magic for the A/B struct when serialized. */
#define AVB_AB_MAGIC "\0AB0"
#define AVB_AB_MAGIC_LEN 4

/* Versioning for the on-disk A/B metadata - keep in sync with avbtool. */
#define AVB_AB_MAJOR_VERSION 1
#define AVB_AB_MINOR_VERSION 0

/* Size of AvbABData struct. */
#define AVB_AB_DATA_SIZE 32

/* Maximum values for slot data */
#define AVB_AB_MAX_PRIORITY 15
#define AVB_AB_MAX_TRIES_REMAINING 4

/* Struct used for recording per-slot metadata.
 *
 * When serialized, data is stored in network byte-order.
 */
typedef struct AvbABSlotData {
	/* Slot priority. Valid values range from 0 to AVB_AB_MAX_PRIORITY,
	 * both inclusive with 1 being the lowest and AVB_AB_MAX_PRIORITY
	 * being the highest. The special value 0 is used to indicate the
	 * slot is unbootable.
	 */
	uint8_t priority;

	/* Number of times left attempting to boot this slot ranging from 0
	 * to AVB_AB_MAX_TRIES_REMAINING.
	 */
	uint8_t tries_remaining;

	/* Non-zero if this slot has booted successfully, 0 otherwise. */
	uint8_t successful_boot;

	/* Reserved for future use. */
	uint8_t reserved[1];
} AvbABSlotData;

/* Struct used for recording A/B metadata.
 *
 * When serialized, data is stored in network byte-order.
 */
typedef struct AvbABData {
	/* Magic number used for identification - see AVB_AB_MAGIC. */
	uint8_t magic[AVB_AB_MAGIC_LEN];

	/* Version of on-disk struct - see AVB_AB_{MAJOR,MINOR}_VERSION. */
	uint8_t version_major;
	uint8_t version_minor;

	/* Padding to ensure |slots| field start eight bytes in. */
	u8 roll_flag;
	u8 reserved1[1];

	/* Per-slot metadata. */
	AvbABSlotData slots[2];

	/* Reserved for future use. */
	uint8_t reserved2[12];

	/* CRC32 of all 28 bytes preceding this field. */
	uint32_t crc32;
}AvbABData;

bool boot_info_validate_VAB(bootloader_control *info)
{
	if (info->magic != BOOT_CTRL_MAGIC) {
		printf("Magic 0x%x is incorrect.\n", info->magic);
		return false;
	}
	return true;
}

bool boot_info_validate(AvbABData* info)
{
	if (memcmp(info->magic, AVB_AB_MAGIC, AVB_AB_MAGIC_LEN) != 0) {
		printf("Magic %s is incorrect.\n", info->magic);
		return false;
	}
	if (info->version_major > AVB_AB_MAJOR_VERSION) {
		printf("No support for given major version.\n");
		return false;
	}
	return true;
}

void boot_info_reset(AvbABData* info)
{
	memset(info, '\0', sizeof(AvbABData));
	memcpy(info->magic, AVB_AB_MAGIC, AVB_AB_MAGIC_LEN);
	info->version_major = AVB_AB_MAJOR_VERSION;
	info->version_minor = AVB_AB_MINOR_VERSION;
	info->slots[0].priority = AVB_AB_MAX_PRIORITY;
	info->slots[0].tries_remaining = AVB_AB_MAX_TRIES_REMAINING;
	info->slots[0].successful_boot = 0;
	info->slots[1].priority = AVB_AB_MAX_PRIORITY - 1;
	info->slots[1].tries_remaining = AVB_AB_MAX_TRIES_REMAINING;
	info->slots[1].successful_boot = 0;
}

void dump_boot_info(AvbABData* info)
{
	int loglevel = getenv_ulong("loglevel", 10, 0);

	if (loglevel >= 5) {
		printf("info->magic = %s\n", info->magic);
		printf("info->version_major = %d\n", info->version_major);
		printf("info->version_minor = %d\n", info->version_minor);
		printf("info->slots[0].priority = %d\n", info->slots[0].priority);
		printf("info->slots[0].tries_remaining = %d\n", info->slots[0].tries_remaining);
		printf("info->slots[0].successful_boot = %d\n", info->slots[0].successful_boot);
		printf("info->slots[1].priority = %d\n", info->slots[1].priority);
		printf("info->slots[1].tries_remaining = %d\n", info->slots[1].tries_remaining);
		printf("info->slots[1].successful_boot = %d\n", info->slots[1].successful_boot);

		printf("info->crc32 = %d\n", info->crc32);
	}
}

void dump_boot_info_VAB(bootloader_control *boot_ctrl)
{
}

static bool slot_is_bootable_VAB(slot_metadata *slot)
{
	return slot->tries_remaining != 0;
}

int get_active_slot_VAB(bootloader_control *info)
{
	if (info->slot_info[0].priority > info->slot_info[1].priority) {
		return 0;
	} else if (info->slot_info[0].priority == info->slot_info[1].priority) {
		if (info->slot_info[0].successful_boot == 1)
			return 0;
		else
			return 1;
	} else {
		return 1;
	}
}

static bool slot_is_bootable(AvbABSlotData* slot) {
	return slot->priority > 0 &&
		(slot->successful_boot || (slot->tries_remaining > 0));
}

int get_active_slot(AvbABData* info) {
	if (info->slots[0].priority > info->slots[1].priority)
		return 0;
	else
		return 1;
}


int boot_info_set_active_slot(AvbABData* info, int slot)
{
	unsigned int other_slot_number;

	/* Make requested slot top priority, unsuccessful, and with max tries. */
	info->slots[slot].priority = AVB_AB_MAX_PRIORITY;
	info->slots[slot].tries_remaining = AVB_AB_MAX_TRIES_REMAINING;
	//info->slots[slot].successful_boot = 0;

	/* Ensure other slot doesn't have as high a priority. */
	other_slot_number = 1 - slot;
	info->slots[other_slot_number].priority -= 1;
	if (info->slots[other_slot_number].priority == AVB_AB_MAX_PRIORITY)
		info->slots[other_slot_number].priority = AVB_AB_MAX_PRIORITY - 1;

	//dump_boot_info(info);

	return 0;
}

int boot_info_open_partition(char *miscbuf)
{
	char *partition = "misc";

	printf("Start read %s partition datas!\n", partition);
	if (store_read_ops((unsigned char *)partition,
		(unsigned char *)miscbuf, 0, MISCBUF_SIZE) < 0) {
		printf("failed to store read %s.\n", partition);
		return -1;
	}

	return 0;
}

bool boot_info_load_VAB(bootloader_control *out_info, char *miscbuf)
{
	memcpy(out_info, miscbuf + AB_METADATA_MISC_PARTITION_OFFSET, sizeof(bootloader_control));
	dump_boot_info_VAB(out_info);
	return true;
}

bool boot_info_load(AvbABData *out_info, char *miscbuf)
{
	memcpy(out_info, miscbuf + AB_METADATA_MISC_PARTITION_OFFSET, AVB_AB_DATA_SIZE);
	dump_boot_info(out_info);
	return true;
}

bool boot_info_save(AvbABData *info, char *miscbuf)
{
	char *partition = "misc";

	printf("save boot-info\n");
	info->crc32 = avb_htobe32(avb_crc32((const uint8_t *)info,
		sizeof(AvbABData) - sizeof(uint32_t)));

	memcpy(miscbuf + AB_METADATA_MISC_PARTITION_OFFSET, info, AVB_AB_DATA_SIZE);
	dump_boot_info(info);
	store_write_ops((unsigned char *)partition, (unsigned char *)miscbuf, 0, MISCBUF_SIZE);
	return true;
}

int write_bootloader(int copy, int dstindex)
{
	int ret = -1;
	unsigned char *buffer = NULL;
	char str[128] = {0};
	u64 addr;
	u64 size = 0x2000 * 512 - 512;

	buffer = (unsigned char *)malloc(size);
	if (!buffer) {
		printf("ERROR! fail to allocate memory ...\n");
		goto exit;
	}
	memset(buffer, 0, size);
	addr = (unsigned long)buffer;

	if (copy == 0) {
		sprintf(str, "amlmmc switch 1 user");
		ret = run_command(str, 0);
	} else if (copy == 1) {
		sprintf(str, "amlmmc switch 1 boot0");
		ret = run_command(str, 0);
	} else if (copy == 2) {
		sprintf(str, "amlmmc switch 1 boot1");
		ret = run_command(str, 0);
	}
	if (ret != 0) {
		printf("amlmmc cmd %s failed\n", str);
		goto exit;
	}

	sprintf(str, "amlmmc read 1 0x%llx 0x1  0x%llx", addr, size / 512);
	printf("command: %s\n", str);
	ret = run_command(str, 0);
	if (ret != 0) {
		printf("amlmmc cmd %s failed\n", str);
		goto exit;
	}

	switch (dstindex) {
		case 0: {
			sprintf(str, "amlmmc switch 1 user");
			ret = run_command(str, 0);
			if (ret != 0) {
				printf("amlmmc cmd %s failed\n", str);
				goto exit;
			}
			sprintf(str, "amlmmc write 1 0x%llx 0x1 0x%llx", addr, size / 512);
			printf("command: %s\n", str);
			ret = run_command(str, 0);
			if (ret != 0) {
				printf("amlmmc cmd %s failed\n", str);
				goto exit;
			}
			break;
		}
		case 1: {
			sprintf(str, "amlmmc switch 1 boot0");
			ret = run_command(str, 0);
			if (ret != 0) {
				printf("amlmmc cmd %s failed\n", str);
				goto exit;
			}
			sprintf(str, "amlmmc write 1 0x%llx 0x1	0x%llx", addr, size / 512);
			printf("command: %s\n", str);
			ret = run_command(str, 0);
			if (ret != 0) {
				printf("amlmmc cmd %s failed\n", str);
				goto exit;
			}
			break;
		}
		case 2: {
			sprintf(str, "amlmmc switch 1 boot1");
			ret = run_command(str, 0);
			if (ret != 0) {
				printf("amlmmc cmd %s failed\n", str);
				goto exit;
			}
			sprintf(str, "amlmmc write 1 0x%llx 0x1	0x%llx", addr, size /  512);
			printf("command: %s\n", str);
			ret = run_command(str, 0);
			if (ret != 0) {
				printf("amlmmc cmd %s failed\n", str);
				goto exit;
			}
			break;
		}
		default: {
			goto exit;
			break;
		}
	}

	sprintf(str, "amlmmc switch 1 user");
	ret = run_command(str, 0);

exit:
	if (buffer) {
		free(buffer);
		buffer = NULL;
	}
	return ret;
}

static int write_bootloader_up(int i)
{
	unsigned char *buffer = NULL;
	int capacity_boot = 0x2000 * 512;
	int ret = 0;
	char partname[32] = {0};
	char *slot_name = NULL;
	int bootloader_index = 0;
	int size = BOOTLOADER_MAX_SIZE - BOOTLOADER_OFFSET;

#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 = getenv("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");

	ret = store_read_ops((unsigned char *)partname, buffer, 0, size);
	if (ret) {
		printf("Fail to read 0x%xB from part[%s] at offset 0\n",
					size, "bootloader_up");
		free(buffer);
		return -1;
	}

	if (i == 0)
		bootloader_index = AML_BL_BOOT0;
	else
		bootloader_index = AML_BL_BOOT1;

	ret = amlmmc_write_bootloader(1, bootloader_index, size, buffer);
	if (ret) {
		printf("Failed to write boot0\n");
		free(buffer);
		return -1;
	}

	free(buffer);
	return 0;
}

void bootloader_update_check(void)
{
	int ret = 0;
	char *writeboot = getenv("write_boot");

	if (writeboot && !strcmp(writeboot, "1")) {
		if (has_boot_slot == 0) {
			printf("non ab for kernel 5.15 update boot0 & boot1 from bootloader_up\n");
			ret = write_bootloader_up(0);
			ret += write_bootloader_up(1);
		} else {
			printf("ab for kernel 5.15 update boot0 from bootloader_a or _b\n");
			ret = write_bootloader_up(0);
		}
		if (ret != 0)
			run_command("reboot", 0);

		setenv("write_boot", "0");
		setenv("upgrade_step", "1");
		run_command("saveenv", 0);
		run_command("reboot", 0);
	}
}

static void update_after_failed_rollback(void)
{
	run_command("run init_display; run storeargs; run update;", 0);
}

void rollback_failure_handler(void) __attribute__((weak, alias("update_after_failed_rollback")));

static int do_GetValidSlot(
	cmd_tbl_t *cmdtp,
	int flag,
	int argc,
	char * const argv[])
{
	char miscbuf[MISCBUF_SIZE] = {0};
	bootloader_control boot_ctrl;
	AvbABData info;
	int slot;
	int AB_mode = 0;
	bool bootable_a, bootable_b;
	char str_count[16];

	if (argc != 1)
		return cmd_usage(cmdtp);

	//recovery mode, need disable dolby
	run_command("get_rebootmode", 0);
	char *rebootmode = getenv("reboot_mode");

	if (rebootmode) {
		if ((!strcmp(rebootmode, "factory_reset")) || (!strcmp(rebootmode, "update")))
			setenv("dolby_status", "0");
	}

	boot_info_open_partition(miscbuf);
	boot_info_load(&info, miscbuf);

	if (!boot_info_validate(&info)) {
		printf("boot-info is invalid. Try VAB.\n");
		boot_info_load_VAB(&boot_ctrl, miscbuf);
		if (!boot_info_validate_VAB(&boot_ctrl)) {
			printf("boot-info is invalid. Resetting.\n");
			boot_info_reset(&info);
			boot_info_save(&info, miscbuf);
		} else {
			printf("rollback from R\n");
			AB_mode = 1;
		}
	}

	//if recovery mode, need disable dolby
	if (!memcmp(miscbuf, "boot-recovery", strlen("boot-recovery"))) {
		printf("recovery mode, need disable dolby\n");
		setenv("dolby_status", "0");
	}

	if (AB_mode == 1) {
		slot = get_active_slot_VAB(&boot_ctrl);
		printf("active slot = %d\n", slot);
		printf("boot_ctrl.roll_flag = %d\n", boot_ctrl.roll_flag);
		bootable_a = slot_is_bootable_VAB(&boot_ctrl.slot_info[0]);
		bootable_b = slot_is_bootable_VAB(&boot_ctrl.slot_info[1]);
		boot_info_reset(&info);
		info.slots[0].successful_boot = boot_ctrl.slot_info[0].successful_boot;
		info.slots[1].successful_boot = boot_ctrl.slot_info[1].successful_boot;
		boot_info_set_active_slot(&info, slot);
		info.roll_flag = boot_ctrl.roll_flag;
		boot_info_save(&info, miscbuf);
	} else {
		slot = get_active_slot(&info);
		printf("active slot = %d\n", slot);
		bootable_a = slot_is_bootable(&info.slots[0]);
		bootable_b = slot_is_bootable(&info.slots[1]);
	}


	if (has_boot_slot == 1) {
		sprintf(str_count, "%d", info.slots[0].tries_remaining);
		setenv("retry-count_a", str_count);
		sprintf(str_count, "%d", info.slots[1].tries_remaining);
		setenv("retry-count_b", str_count);
	}

	if (dynamic_partition)
		setenv("partition_mode", "dynamic");
	else
		setenv("partition_mode", "normal");

	if (vendor_boot_partition) {
		setenv("vendor_boot_mode", "true");
		printf("set vendor_boot_mode true\n");
	} else {
		setenv("vendor_boot_mode", "false");
		printf("set vendor_boot_mode false\n");
	}
	if (slot == 0) {
		if (bootable_a) {
			if (has_boot_slot == 1) {
				setenv("active_slot", "_a");
				setenv("boot_part", "boot_a");
				setenv("recovery_part", "recovery_a");
				setenv("slot-suffixes", "0");
			} else {
				setenv("active_slot", "normal");
				setenv("boot_part", "boot");
				setenv("recovery_part", "recovery");
				setenv("slot-suffixes", "-1");
			}
		} else if (bootable_b) {
			info.roll_flag = 1;
			boot_info_save(&info, miscbuf);
			run_command("set_active_slot b", 0);
			setenv("default_env", "1");
			run_command("saveenv", 0);
#ifdef CONFIG_AML_GPT
			if (write_bootloader(2, 1) == 0)  {
#else
			if (write_bootloader(2, 0) == 0)  {
#endif
				printf("rollback ok\n");
				run_command("reset", 0);
			} else {
				printf("rollback failed\n");
				rollback_failure_handler();
			}
		} else {
			rollback_failure_handler();
		}
	}

	if (slot == 1) {
		if (bootable_b) {
			if (has_boot_slot == 1) {
				setenv("active_slot", "_b");
				setenv("boot_part", "boot_b");
				setenv("recovery_part", "recovery_b");
				setenv("slot-suffixes", "1");
			} else {
				setenv("active_slot", "normal");
				setenv("boot_part", "boot");
				setenv("recovery_part", "recovery");
				setenv("slot-suffixes", "-1");
			}
		} else if (bootable_a) {
			info.roll_flag = 1;
			boot_info_save(&info, miscbuf);
			run_command("set_active_slot a", 0);
			setenv("default_env", "1");
			run_command("saveenv", 0);

#ifdef CONFIG_AML_GPT
			if (write_bootloader(2, 1) == 0)  {
#else
			if (write_bootloader(1, 0) == 0)  {
#endif
				printf("rollback ok\n");
				run_command("reset", 0);
			} else {
				printf("rollback failed\n");
				rollback_failure_handler();
			}
		} else {
			rollback_failure_handler();
		}
	}

	if (rebootmode && (strcmp(rebootmode, "rescueparty") == 0)) {
		printf("rebootmode is rescueparty, need rollback\n");

		if (slot == 0) {
			info.roll_flag = 1;
			boot_info_save(&info, miscbuf);
			run_command("set_active_slot b", 0);
			setenv("default_env", "1");
			run_command("saveenv", 0);
#ifdef CONFIG_AML_GPT
			if (write_bootloader(2, 1) == 0)  {
#else
			if (write_bootloader(2, 0) == 0)  {
#endif
				printf("rollback ok\n");
				run_command("reset", 0);
			} else {
				printf("rollback failed\n");
				rollback_failure_handler();
			}
		} else if (slot == 1) {
			info.roll_flag = 1;
			boot_info_save(&info, miscbuf);
			run_command("set_active_slot a", 0);
			setenv("default_env", "1");
			run_command("saveenv", 0);
#ifdef CONFIG_AML_GPT
			if (write_bootloader(2, 1) == 0)  {
#else
			if (write_bootloader(1, 0) == 0)  {
#endif
				printf("rollback ok\n");
				run_command("reset", 0);
			} else {
				printf("rollback failed\n");
				rollback_failure_handler();
			}
		}
	}

	bootloader_update_check();
	return 0;
}

static int do_SetActiveSlot(
	cmd_tbl_t *cmdtp,
	int flag,
	int argc,
	char * const argv[])
{
	char miscbuf[MISCBUF_SIZE] = {0};
	AvbABData info;

	if (argc != 2)
		return cmd_usage(cmdtp);

	if (has_boot_slot == 0) {
		printf("device is not ab mode\n");
		return -1;
	}

	boot_info_open_partition(miscbuf);
	boot_info_load(&info, miscbuf);

	if (!boot_info_validate(&info)) {
		printf("boot-info is invalid. Resetting.\n");
		boot_info_reset(&info);
		boot_info_save(&info, miscbuf);
	}

	if (strcmp(argv[1], "a") == 0) {
		setenv("active_slot", "_a");
		setenv("slot-suffixes", "0");
		setenv("boot_part", "boot_a");
		setenv("recovery_part", "recovery_a");
		printf("set active slot a\n");
		boot_info_set_active_slot(&info, 0);
	} else if (strcmp(argv[1], "b") == 0) {
		setenv("active_slot", "_b");
		setenv("slot-suffixes", "1");
		setenv("boot_part", "boot_b");
		setenv("recovery_part", "recovery_b");
		printf("set active slot b\n");
		boot_info_set_active_slot(&info, 1);
	} else {
		printf("error input slot\n");
		return -1;
	}

	boot_info_save(&info, miscbuf);

	printf("info.roll_flag = %d\n", info.roll_flag);

	if (info.roll_flag == 1) {
		printf("if null gpt, write dtb back when rollback\n");
		run_command("imgread dtb ${boot_part} ${dtb_mem_addr}", 0);
		run_command("emmc dtb_write ${dtb_mem_addr} 0", 0);
	}

	return 0;
}

static int do_SetUpdateTries
(cmd_tbl_t *cmdtp,
	int flag,
	int argc,
	char * const argv[])
{
	char miscbuf[MISCBUF_SIZE] = {0};
	AvbABData info;
	int slot;
	bool bootable_a, bootable_b;
	int update_flag = 0;

	if (has_boot_slot == 0) {
		printf("device is not ab mode\n");
		return -1;
	}

	//unsupport update dt in boothal, update dt in uboot
	run_command("update_dt;", 0);

	boot_info_open_partition(miscbuf);
	boot_info_load(&info, miscbuf);

	if (!boot_info_validate(&info)) {
		printf("boot-info is invalid. Resetting.\n");
		boot_info_reset(&info);
		boot_info_save(&info, miscbuf);
	}

	slot = get_active_slot(&info);
	bootable_a = slot_is_bootable(&info.slots[0]);
	bootable_b = slot_is_bootable(&info.slots[1]);

	if (slot == 0) {
		if (bootable_a) {
			if (info.slots[0].successful_boot == 0) {
				info.slots[0].tries_remaining -= 1;
				update_flag = 1;
			}
		}
	}

	if (slot == 1) {
		if (bootable_b) {
			if (info.slots[1].successful_boot == 0) {
				info.slots[1].tries_remaining -= 1;
				update_flag = 1;
			}
		}
	}

	if (update_flag == 1)
		boot_info_save(&info, miscbuf);

	printf("%s info.roll_flag = %d\n",  __func__, info.roll_flag);
	if (info.roll_flag == 1)
		setenv("rollback_flag", "1");

	return 0;
}

static int do_SetRollFlag
(cmd_tbl_t *cmdtp,
	int flag,
	int argc,
	char * const argv[])
{
	char miscbuf[MISCBUF_SIZE] = {0};
	AvbABData info;

	if (has_boot_slot == 0) {
		printf("device is not ab mode\n");
		return -1;
	}

	boot_info_open_partition(miscbuf);
	boot_info_load(&info, miscbuf);

	if (!boot_info_validate(&info)) {
		printf("boot-info is invalid. Resetting.\n");
		return 0;
	}

	if (strcmp(argv[1], "1") == 0)
		info.roll_flag = 1;
	else
		info.roll_flag = 0;

	boot_info_save(&info, miscbuf);

	printf("set info.roll_flag = %d\n", info.roll_flag);

	return 0;
}

static int do_Get_slot_state(
	cmd_tbl_t *cmdtp,
	int flag,
	int argc,
	char * const argv[])
{
		char miscbuf[MISCBUF_SIZE] = {0};
	AvbABData info;

	if (argc != 3)
		return cmd_usage(cmdtp);

	if (has_boot_slot == 0) {
		printf("device is not ab mode\n");
		return -1;
	}

	boot_info_open_partition(miscbuf);
	boot_info_load(&info, miscbuf);

	if (!boot_info_validate(&info)) {
		printf("boot-info is invalid. Resetting.\n");
		boot_info_reset(&info);
		boot_info_save(&info, miscbuf);
	}

	if (strcmp(argv[2], "suc_stete") == 0) {
		if (strcmp(argv[1], "a") == 0) {
			if (info.slots[0].successful_boot == 1)
				return 1;
			else
				return 0;
		}
		if (strcmp(argv[1], "b") == 0) {
			if (info.slots[1].successful_boot == 1)
				return 1;
			else
				return 0;
		}
	}

	if (strcmp(argv[2], "boot_state") == 0) {
		if (strcmp(argv[1], "a") == 0) {
			if (slot_is_bootable(&info.slots[0]))
				return 1;
			else
				return 0;
		}
		if (strcmp(argv[1], "b") == 0) {
			if (slot_is_bootable(&info.slots[1]))
				return 1;
			else
				return 0;
		}
	}

	return -1;
}

int do_GetSystemMode (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#ifdef CONFIG_SYSTEM_AS_ROOT
	setenv("system_mode", "1");
#else
	setenv("system_mode", "0");
#endif

	return 0;
}


int do_UpdateDt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	char *update_dt = getenv("update_dt");
	char *part_changed = getenv("part_changed");

	if (update_dt && (!strcmp(update_dt, "1"))) {
		printf("write dtb\n");
		run_command("imgread dtb ${boot_part} ${dtb_mem_addr}", 0);
		run_command("emmc dtb_write ${dtb_mem_addr} 0", 0);

		setenv("update_dt", "0");
		run_command("saveenv", 0);

		if (part_changed && (!strcmp(part_changed, "1"))) {
			setenv("part_changed", "0");
			run_command("saveenv", 0);

			run_command("reset", 0);
		}
	}
	return 0;
}

#endif /* CONFIG_BOOTLOADER_CONTROL_BLOCK */

U_BOOT_CMD(
get_valid_slot, 2, 0, do_GetValidSlot,
"get_valid_slot",
"\nThis command will choose valid slot to boot up which saved in misc\n"
"partition by mark to decide whether execute command!\n"
"So you can execute command: get_valid_slot"
);

U_BOOT_CMD(
set_active_slot, 2, 1, do_SetActiveSlot,
"set_active_slot",
"\nThis command will set active slot\n"
"So you can execute command: set_active_slot a"
);

U_BOOT_CMD
(set_roll_flag, 2, 1, do_SetRollFlag,
	"set_roll_flag",
	"\nThis command will set active slot\n"
	"So you can execute command: set_active_slot a"
);

U_BOOT_CMD
(update_tries, 2, 0, do_SetUpdateTries,
	"update_tries",
	"\nThis command will change tries_remaining in misc\n"
	"So you can execute command: update_tries"
);

U_BOOT_CMD(
get_slot_state, 3, 2, do_Get_slot_state,
"get_slot_state a suc_stete",
"\nThis command will get slot state\n"
"you can run: get_slot_state a suc_stete/boot_state"
);


U_BOOT_CMD(
get_system_as_root_mode, 1,	0, do_GetSystemMode,
"get_system_as_root_mode",
"\nThis command will get system_as_root_mode\n"
"So you can execute command: get_system_as_root_mode"
);

U_BOOT_CMD
(update_dt, 1,	0, do_UpdateDt,
	"update_dt",
	"\nThis command will update dt\n"
	"So you can execute command: update_dt"
);