// SPDX-License-Identifier: BSD-2-Clause
/*
 * Copyright (C) 2016 The Android Open Source Project
 */

#include <common.h>
#include <fastboot.h>
#include <fastboot-internal.h>
#include <fb_mmc.h>
#include <fb_nand.h>
#include <part.h>
#include <stdlib.h>
#include <emmc_partitions.h>
#include <amlogic/storage.h>

/**
 * image_size - final fastboot image size
 */
static u32 image_size;

/**
 * fastboot_bytes_received - number of bytes received in the current download
 */
static u32 fastboot_bytes_received;

/**
 * fastboot_bytes_expected - number of bytes expected in the current download
 */
static u32 fastboot_bytes_expected;

int busy_flag;

static void okay(char *, char *);
static void getvar(char *, char *);
static void download(char *, char *);
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
static void flash(char *, char *);
static void erase(char *, char *);
#endif
static void flashing(char *, char *);
static void reboot_bootloader(char *, char *);
static void reboot_fastboot(char *, char *);
#if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT)
static void oem_format(char *, char *);
#endif
static void oem_cmd(char *, char *);
static void set_active_cmd(char *, char *);
static void snapshot_update_cmd(char *, char *);

#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK
extern int is_partition_logical(char* parition_name);
#endif

static const struct {
	const char *command;
	void (*dispatch)(char *cmd_parameter, char *response);
} commands[FASTBOOT_COMMAND_COUNT] = {
	[FASTBOOT_COMMAND_GETVAR] = {
		.command = "getvar",
		.dispatch = getvar
	},
	[FASTBOOT_COMMAND_DOWNLOAD] = {
		.command = "download",
		.dispatch = download
	},
#if !CONFIG_IS_ENABLED(NO_FASTBOOT_FLASHING)
	[FASTBOOT_COMMAND_FLASHING] =  {
		.command = "flashing",
		.dispatch = flashing
	},
#endif// #if !CONFIG_IS_ENABLED(NO_FASTBOOT_FLASHING)
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
	[FASTBOOT_COMMAND_FLASH] =  {
		.command = "flash",
		.dispatch = flash
	},
	[FASTBOOT_COMMAND_ERASE] =  {
		.command = "erase",
		.dispatch = erase
	},
#endif
	[FASTBOOT_COMMAND_BOOT] =  {
		.command = "boot",
		.dispatch = okay
	},
	[FASTBOOT_COMMAND_CONTINUE] =  {
		.command = "continue",
		.dispatch = okay
	},
	[FASTBOOT_COMMAND_REBOOT_BOOTLOADER] =  {
		.command = "reboot-bootloader",
		.dispatch = reboot_bootloader
	},
	[FASTBOOT_COMMAND_REBOOT_FASTBOOT] =  {
		.command = "reboot-fastboot",
		.dispatch = reboot_fastboot
	},
	[FASTBOOT_COMMAND_REBOOT] =  {
		.command = "reboot",
		.dispatch = okay
	},
	[FASTBOOT_COMMAND_SET_ACTIVE] =  {
		.command = "set_active",
		.dispatch = set_active_cmd
	},
	[FASTBOOT_COMMAND_SNAOSHOT_UPDATE] =  {
		.command = "snapshot-update",
		.dispatch = snapshot_update_cmd
	},
#if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT)
	[FASTBOOT_COMMAND_OEM_FORMAT] = {
		.command = "oem format",
		.dispatch = oem_format,
	},
#endif
	[FASTBOOT_COMMAND_OEM] = {
		.command = "oem",
		.dispatch = oem_cmd,
	},
};

static int strcmp_l1(const char *s1, const char *s2)
{
	if (!s1 || !s2)
		return -1;
	return strncmp(s1, s2, strlen(s1));
}

/**
 * fastboot_handle_command - Handle fastboot command
 *
 * @cmd_string: Pointer to command string
 * @response: Pointer to fastboot response buffer
 *
 * Return: Executed command, or -1 if not recognized
 */
int fastboot_handle_command(char *cmd_string, char *response)
{
	int i;
	char *cmd_parameter;

	cmd_parameter = cmd_string;
	strsep(&cmd_parameter, ":");

	for (i = 0; i < FASTBOOT_COMMAND_COUNT; i++) {
		if (!strcmp_l1(commands[i].command, cmd_string)) {
			if (commands[i].dispatch) {
				if (strcmp(cmd_parameter, NULL)) {
					commands[i].dispatch(cmd_parameter,
							response);
				} else {
					commands[i].dispatch(cmd_string,
							response);
				}
				return i;
			} else {
				break;
			}
		}
	}

	pr_err("command %s not recognized.\n", cmd_string);
	fastboot_fail("unrecognized command", response);
	return -1;
}

/**
 * okay() - Send bare OKAY response
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 *
 * Send a bare OKAY fastboot response. This is used where the command is
 * valid, but all the work is done after the response has been sent (e.g.
 * boot, reboot etc.)
 */
static void okay(char *cmd_parameter, char *response)
{
	fastboot_okay(NULL, response);
}

void dump_lock_info(LockData_t* info)
{
#if 0
	printf("info->version_major = %d\n", info->version_major);
	printf("info->version_minor = %d\n", info->version_minor);
	printf("info->unlock_ability = %d\n", info->unlock_ability);
	printf("info->lock_state = %d\n", info->lock_state);
	printf("info->lock_critical_state = %d\n", info->lock_critical_state);
	printf("info->lock_bootloader = %d\n", info->lock_bootloader);
#endif
}

static const char* getvar_list[] = {
	"version-baseband", "version-bootloader", "version", "hw-revision", "max-download-size",
	"serialno", "product", "off-mode-charge", "variant", "battery-soc-ok",
	"battery-voltage", "partition-type:boot", "partition-size:boot",
	"partition-type:system", "partition-size:system", "partition-type:vendor", "partition-size:vendor",
	"partition-type:odm", "partition-size:odm", "partition-type:data", "partition-size:data",
	"erase-block-size", "logical-block-size", "secure", "unlocked",
};

static const char* getvar_list_dynamic[] = {
	"hw-revision", "battery-voltage", "is-userspace", "is-logical:data",
	"is-logical:metadata", "is-logical:misc", "is-logical:super", "is-logical:boot",
	"is-logical:system", "is-logical:vendor", "is-logical:product", "is-logical:odm",
	"slot-count", "max-download-size", "serialno", "product", "unlocked",
	"secure", "super-partition-name", "version-baseband", "version-bootloader",
	"partition-size:boot", "partition-size:metadata", "partition-size:misc",
	"partition-size:super", "partition-size:data", "version",
};

static const char* getvar_list_dynamic_ab[] = {
	"hw-revision", "battery-voltage", "is-userspace", "is-logical:data",
	"is-logical:misc", "is-logical:super",
	"is-logical:boot_a", "is-logical:boot_b", "is-logical:system_a", "is-logical:system_b",
	"is-logical:vendor_a", "is-logical:vendor_b", "is-logical:product_a", "is-logical:product_b",
	"is-logical:odm_a", "is-logical:odm_b",
	"slot-count", "max-download-size", "serialno", "product", "unlocked", "has-slot:data",
	"has-slot:metadata", "has-slot:misc", "has-slot:super", "has-slot:boot",
	"has-slot:system", "has-slot:vendor", "has-slot:product", "has-slot:odm", "current-slot",
	"secure", "super-partition-name", "version-baseband", "version-bootloader",
	"partition-size:super",
	"partition-size:boot_a", "partition-size:boot_b", "partition-size:misc",
	"partition-size:data", "version",
};


static const char* getvar_list_ab[] = {
	"version-baseband", "version-bootloader", "version", "hw-revision", "max-download-size",
	"serialno", "product", "off-mode-charge", "variant", "battery-soc-ok",
	"battery-voltage", "partition-type:boot_a", "partition-size:boot_a",
	"partition-type:system_a", "partition-size:system_a", "partition-type:vendor_a", "partition-size:vendor_a",
	"partition-type:odm_a", "partition-size:odm_a", "partition-type:data", "partition-size:data",
	"erase-block-size", "logical-block-size", "secure", "unlocked",
	"slot-count", "slot-suffixes","current-slot", "has-slot:bootloader", "has-slot:boot",
	"has-slot:system", "has-slot:vendor", "has-slot:odm", "has-slot:vbmeta",
	"has-slot:metadata", "has-slot:product", "has-slot:dtbo",
	"slot-successful:a", "slot-unbootable:a", "slot-retry-count:a",
	"slot-successful:b", "slot-unbootable:b", "slot-retry-count:b",
};


/**
 * getvar() - Read a config/version variable
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 */
static void getvar(char *cmd_parameter, char *response)
{
	run_command("get_valid_slot", 0);
	if (!strncmp(cmd_parameter, "all", 3)) {
		static int cmdIndex = 0;
		int getvar_num = 0;
		char* cmd=cmd_parameter;

		busy_flag = 1;

		if (dynamic_partition && has_boot_slot == 1 && strlen(getvar_list_dynamic_ab[cmdIndex]) < 64) {
			strncpy(cmd, getvar_list_dynamic_ab[cmdIndex], 64);
			getvar_num = (sizeof(getvar_list_dynamic_ab) / sizeof(getvar_list_dynamic_ab[0]));
		} else if (has_boot_slot == 1 && strlen(getvar_list_ab[cmdIndex]) < 64) {
			strncpy(cmd, getvar_list_ab[cmdIndex], 64);
			getvar_num = (sizeof(getvar_list_ab) / sizeof(getvar_list_ab[0]));
		} else if (dynamic_partition && strlen(getvar_list_dynamic[cmdIndex]) < 64) {
			strncpy(cmd, getvar_list_dynamic[cmdIndex], 64);//only support no-arg cmd
			getvar_num = (sizeof(getvar_list_dynamic) / sizeof(getvar_list_dynamic[0]));
		} else if (strlen(getvar_list[cmdIndex]) < 64) {
			strncpy(cmd, getvar_list[cmdIndex], 64);//only support no-arg cmd
			getvar_num = (sizeof(getvar_list) / sizeof(getvar_list[0]));
		}
		//printf("getvar_num: %d\n", getvar_num);
		//printf("all cmd:%s\n", cmd);
		if ( ++cmdIndex >= getvar_num) {
			cmdIndex = 0;
			busy_flag = 0;
			fastboot_okay(NULL, response);
		} else {
			fastboot_getvar(cmd, response);
		}

	}else {
		fastboot_getvar(cmd_parameter, response);
	}
}

/**
 * fastboot_download() - Start a download transfer from the client
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 */
static void download(char *cmd_parameter, char *response)
{
	char *tmp;

	if (!cmd_parameter) {
		fastboot_fail("Expected command parameter", response);
		return;
	}
	fastboot_bytes_received = 0;
	fastboot_bytes_expected = simple_strtoul(cmd_parameter, &tmp, 16);
	if (fastboot_bytes_expected == 0) {
		fastboot_fail("Expected nonzero image size", response);
		return;
	}
	/*
	 * Nothing to download yet. Response is of the form:
	 * [DATA|FAIL]$cmd_parameter
	 *
	 * where cmd_parameter is an 8 digit hexadecimal number
	 */
	if (fastboot_bytes_expected > fastboot_buf_size) {
		fastboot_fail(cmd_parameter, response);
	} else {
		printf("Starting download of %d bytes\n",
		       fastboot_bytes_expected);
		fastboot_response("DATA", response, "%s", cmd_parameter);
	}
}

/**
 * fastboot_data_remaining() - return bytes remaining in current transfer
 *
 * Return: Number of bytes left in the current download
 */
u32 fastboot_data_remaining(void)
{
	return fastboot_bytes_expected - fastboot_bytes_received;
}

/**
 * fastboot_data_download() - Copy image data to fastboot_buf_addr.
 *
 * @fastboot_data: Pointer to received fastboot data
 * @fastboot_data_len: Length of received fastboot data
 * @response: Pointer to fastboot response buffer
 *
 * Copies image data from fastboot_data to fastboot_buf_addr. Writes to
 * response. fastboot_bytes_received is updated to indicate the number
 * of bytes that have been transferred.
 *
 * On completion sets image_size and ${filesize} to the total size of the
 * downloaded image.
 */
void fastboot_data_download(const void *fastboot_data,
			    unsigned int fastboot_data_len,
			    char *response)
{
#define BYTES_PER_DOT	0x20000
	u32 pre_dot_num, now_dot_num;

	if (fastboot_data_len == 0 ||
	    (fastboot_bytes_received + fastboot_data_len) >
	    fastboot_bytes_expected) {
		fastboot_fail("Received invalid data length",
			      response);
		return;
	}
	/* Download data to fastboot_buf_addr */
	memcpy(fastboot_buf_addr + fastboot_bytes_received,
	       fastboot_data, fastboot_data_len);

	pre_dot_num = fastboot_bytes_received / BYTES_PER_DOT;
	fastboot_bytes_received += fastboot_data_len;
	now_dot_num = fastboot_bytes_received / BYTES_PER_DOT;

	if (pre_dot_num != now_dot_num) {
		putc('.');
		if (!(now_dot_num % 74))
			putc('\n');
	}
	*response = '\0';
}

/**
 * fastboot_data_complete() - Mark current transfer complete
 *
 * @response: Pointer to fastboot response buffer
 *
 * Set image_size and ${filesize} to the total size of the downloaded image.
 */
void fastboot_data_complete(char *response)
{
	/* Download complete. Respond with "OKAY" */
	fastboot_okay(NULL, response);
	printf("\ndownloading of %d bytes finished\n", fastboot_bytes_received);
	image_size = fastboot_bytes_received;
	env_set_hex("filesize", image_size);
	fastboot_bytes_expected = 0;
	fastboot_bytes_received = 0;
}

#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
/**
 * flash() - write the downloaded image to the indicated partition.
 *
 * @cmd_parameter: Pointer to partition name
 * @response: Pointer to fastboot response buffer
 *
 * Writes the previously downloaded image to the partition indicated by
 * cmd_parameter. Writes to response.
 */
static void flash(char *cmd_parameter, char *response)
{
	char name[32] = {0};
	u64 rc = 0;

	if (check_lock() == 1) {
		printf("device is locked, can not run this cmd.Please flashing unlock & flashing unlock_critical\n");
		fastboot_fail("locked device", response);
		return;
	}

	printf("cmd_parameter: %s\n", cmd_parameter);

#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
#ifdef CONFIG_AML_GPT
	struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
	if (mmc && strcmp(cmd_parameter, "bootloader") == 0) {
		printf("try to read gpt data from bootloader.img\n");
		struct blk_desc *dev_desc;
		/* the max size of bootloader.img is 4M, we reserve 128k for gpt.bin
		 * so we put gpt.bin at offset 0x3DFE00
		 * 0 ~ 512 bootloader secure boot, we don't care it here.
		 * 512 ~ 0x3DFDFF  original bootloader.img and 0
		 * 0x3DFE00 ~ end  gpt.bin
		 */

		dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
		if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
			printf("invalid mmc device\n");
			fastboot_fail("invalid mmc device", response);
			return;
		}

		if (is_valid_gpt_buf(dev_desc, fastboot_buf_addr + 0x3DFE00)) {
			printf("printf normal bootloader.img, no gpt partition table\n");
		} else {
			printf("find gpt parition table, update it\n"
				"and write bootloader to boot0/boot1\n");

			if (write_mbr_and_gpt_partitions(dev_desc, fastboot_buf_addr + 0x3DFE00)) {
				printf("%s: writing GPT partitions failed\n", __func__);
				fastboot_fail("writing GPT partitions failed", response);
				return;
			}
			if (mmc_device_init(mmc) != 0) {
				printf(" update gpt partition table fail\n");
				fastboot_fail("fastboot update gpt partition fail", response);
				return;
			}
			printf("%s: writing GPT partitions ok\n", __func__);
		}

		if (aml_gpt_valid(mmc) == 0) {
			printf("gpt mode\n");
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
			fastboot_mmc_flash_write("bootloader-boot0", fastboot_buf_addr, image_size,
				 response);
			fastboot_mmc_flash_write("bootloader-boot1", fastboot_buf_addr, image_size,
				 response);
			run_command("mmc dev 1 0;", 0);
#endif
			env_set("default_env", "1");
			run_command("saveenv;", 0);
			return;
		}
	}
#endif  // CONFIG_AML_GPT

#if CONFIG_IS_ENABLED(CHROMECAST_AB)
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
	char *slot = env_get("slot-suffixes");
	if ((!strcmp(slot, "0") && !strcmp(cmd_parameter, "bootloader_a")) ||
	    (!strcmp(slot, "1") && !strcmp(cmd_parameter, "bootloader_b"))) {
		fastboot_mmc_flash_write("bootloader-boot0", fastboot_buf_addr,
					 image_size, response);
		fastboot_mmc_flash_write("bootloader-boot1", fastboot_buf_addr,
					 image_size, response);
		run_command("mmc dev 1 0;", 0);
	}
#endif
#endif

#endif  // CONFIG_FASTBOOT_FLASH_MMC_DEV

	if (strcmp(cmd_parameter, "userdata") == 0 || strcmp(cmd_parameter, "data") == 0) {
		rc = store_part_size("userdata");
		if (-1 == rc)
			strncpy(name, "data", 4);
		else
			strncpy(name, "userdata", 8);
	} else if (strcmp(cmd_parameter, "dts") == 0) {
		strncpy(name, "dtb", 3);
	} else {
		strncpy(name, cmd_parameter, 32);
	}

#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK
	if (dynamic_partition) {
		if (is_partition_logical(name) == 0) {
			printf("%s is logic partition, can not write here.......\n", name);
			fastboot_fail("logic partition", response);
			return;
		}
	}
#endif

#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
	fastboot_mmc_flash_write(name, fastboot_buf_addr, image_size,
				 response);
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_NAND)
	fastboot_nand_flash_write(name, fastboot_buf_addr, image_size,
				  response);
#endif

	if (strcmp(name, "bootloader") == 0) {
		env_set("default_env", "1");
		run_command("saveenv;", 0);
	}
}

/**
 * erase() - erase the indicated partition.
 *
 * @cmd_parameter: Pointer to partition name
 * @response: Pointer to fastboot response buffer
 *
 * Erases the partition indicated by cmd_parameter (clear to 0x00s). Writes
 * to response.
 */
static void erase(char *cmd_parameter, char *response)
{
	char name[32] = {0};
	u64 rc = 0;

	if (check_lock() == 1) {
		printf("device is locked, can not run this cmd.Please flashing unlock & flashing unlock_critical\n");
		fastboot_fail("locked device", response);
		return;
	}

	printf("cmd_parameter: %s\n", cmd_parameter);

#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
#ifdef CONFIG_AML_GPT
	struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
	if ((mmc != NULL) && strcmp(cmd_parameter, "bootloader") == 0 && (aml_gpt_valid(mmc) == 0)) {
		printf("we write gpt partition table to bootloader now\n");
		printf("plese write bootloader to bootloader-boot0/bootloader-boot1\n");
		fastboot_okay("gpt mode, skip", response);
		return;
	}
#endif
#endif

	struct misc_virtual_ab_message message;
	get_mergestatus(&message);

	if (strcmp(cmd_parameter, "userdata") == 0 || strcmp(cmd_parameter, "data") == 0) {
		rc = store_part_size("userdata");
		if (-1 == rc)
			strncpy(name, "data", 4);
		else
			strncpy(name, "userdata", 8);
		if (message.merge_status == SNAPSHOTTED || message.merge_status == MERGING) {
			fastboot_fail("in merge state, cannot erase data", response);
			return;
		}
	} else if (strcmp(cmd_parameter, "dts") == 0) {
		strncpy(name, "dtb", 3);
	} else {
		strncpy(name, cmd_parameter, 32);
	}

#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK
		if (dynamic_partition) {
			if (is_partition_logical(name) == 0) {
				printf("%s is logic partition, can not erase here.......\n", name);
				fastboot_fail("logic partition", response);
				return;
			}
		}
#endif

#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
	fastboot_mmc_erase(name, response);
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_NAND)
	fastboot_nand_erase(name, response);
#endif
}
#endif

static void set_active_cmd(char *cmd_parameter, char *response)
{
	char *cmd;
	int ret = 0;
	char str[128];

	printf("cmd cb_set_active is %s\n", cmd_parameter);
	cmd = cmd_parameter;

	if (check_lock() == 1) {
		printf("device is locked, can not run this cmd.Please flashing unlock & flashing unlock_critical\n");
		fastboot_fail("locked device", response);
		return;
	}

	struct misc_virtual_ab_message message;
	get_mergestatus(&message);
	if (message.merge_status == MERGING) {
		fastboot_fail("in merge state, cannot set active", response);
		return;
	}

	sprintf(str, "set_active_slot %s", cmd);
	printf("command:    %s\n", str);
	ret = run_command(str, 0);
	printf("ret = %d\n", ret);
	if (ret == 0)
		fastboot_okay(NULL, response);
	else
		fastboot_fail("set slot error", response);
}

static void snapshot_update_cmd(char *cmd_parameter, char *response)
{
	char *cmd;

	printf("cmd snapshot_update_cmd is %s\n", cmd_parameter);
	cmd = cmd_parameter;

	if (check_lock() == 1) {
		printf("device is locked, can not run this cmd.Please flashing unlock & flashing unlock_critical\n");
		fastboot_fail("locked device", response);
		return;
	}

	if (!strcmp_l1("cancel", cmd)) {
		struct misc_virtual_ab_message message;
		set_mergestatus_cancel(&message);
	}
	fastboot_okay(NULL, response);
}

#if !CONFIG_IS_ENABLED(NO_FASTBOOT_FLASHING)
/**
 * flashing() - lock/unlock.
 *
 * @cmd_parameter: Pointer to partition name
 * @response: Pointer to fastboot response buffer
 *
 * Writes the previously downloaded image to the partition indicated by
 * cmd_parameter. Writes to response.
 */
static void flashing(char *cmd_parameter, char *response)
{
	char *cmd;
	char* lock_s;
	LockData_t* info;
	char lock_d[LOCK_DATA_SIZE];
	u64 rc;

	lock_s = env_get("lock");
	if (!lock_s) {
		printf("lock state is NULL \n");
		strncpy(lock_d, "10101000", 8);
		lock_s = "10101000";
		env_set("lock", "10101000");
		run_command("defenv_reserv; saveenv;", 0);
	} else {
		printf("lock state: %s\n", lock_s);
		if (strlen(lock_s) > 15)
			strncpy(lock_d, lock_s, 15);
		else
			strncpy(lock_d, lock_s, strlen(lock_s));
	}

	info = malloc(sizeof(struct LockData));
	if (!info) {
		printf("malloc error\n");
		fastboot_fail("malloc error", response);
		return;
	}
	memset(info,0,LOCK_DATA_SIZE);
	info->version_major = (int)(lock_d[0] - '0');
	info->version_minor = (int)(lock_d[1] - '0');
	info->unlock_ability = (int)(lock_d[2] - '0');
	info->lock_state = (int)(lock_d[4] - '0');
	info->lock_critical_state = (int)(lock_d[5] - '0');
	info->lock_bootloader = (int)(lock_d[6] - '0');

	printf("cb_flashing cmd_parameter: %s\n", cmd_parameter);
	cmd = cmd_parameter;
	strsep(&cmd, " ");
	printf("cb_flashing: %s\n", cmd);
	if (!cmd) {
		printf("missing variable\n");
		fastboot_fail("missing var", response);
		free(info);
		return;
	}

	rc = store_part_size("userdata");

	if (!strcmp_l1("unlock_critical", cmd)) {
		info->lock_critical_state = 0;
		fastboot_okay(NULL, response);
	} else if (!strcmp_l1("lock_critical", cmd)) {
		info->lock_critical_state = 1;
		fastboot_okay(NULL, response);
	} else if (!strcmp_l1("get_unlock_ability", cmd)) {
		char str[32];
		static bool is_unlock_ability_sent = false;
		if (is_unlock_ability_sent) {
			is_unlock_ability_sent = false;
			fastboot_okay(NULL, response);
			busy_flag = 0;
		} else {
			sprintf(str, "get_unlock_ability: %d",
				info->unlock_ability);
			fastboot_response("INFO", response, "%s", str);
			is_unlock_ability_sent = true;
			busy_flag = 1;
		}
		free(info);
		return;
	} else if (!strcmp_l1("get_unlock_bootloader_nonce", cmd)) {
		char str_num[8];
		sprintf(str_num, "%d", info->lock_critical_state);
		fastboot_response("OKAY", response, "%s", str_num);
	} else if (!strcmp_l1("lock_bootloader", cmd)) {
		info->lock_bootloader = 1;
	} else if (!strcmp_l1("unlock", cmd)) {
		if (info->unlock_ability == 1 ) {
			if (info->lock_state == 1 ) {
				char *avb_s;
				avb_s = env_get("avb2");
				if (avb_s == NULL) {
					run_command("get_avb_mode;", 0);
					avb_s = env_get("avb2");
				}
				printf("avb2: %s\n", avb_s);
				if (strcmp(avb_s, "1") == 0) {
#ifdef CONFIG_AML_ANTIROLLBACK
					if (avb_unlock()) {
						if (-1 == rc) {
							printf("unlocking device.  Erasing data partition!\n");
							run_command("store erase data 0 0", 0);
						} else {
							printf("unlocking device.  Erasing userdata partition!\n");
							run_command("store erase userdata 0 0", 0);
						}
						printf("unlocking device.  Erasing metadata partition!\n");
						run_command("store erase metadata 0 0", 0);
					} else {
						printf("unlock failed!\n");
					}
#else
					if (-1 == rc) {
						printf("unlocking device.  Erasing data partition!\n");
						run_command("store erase data 0 0", 0);
					} else {
						printf("unlocking device.  Erasing userdata partition!\n");
						run_command("store erase userdata 0 0", 0);
					}
					printf("unlocking device.  Erasing metadata partition!\n");
					run_command("store erase metadata 0 0", 0);
#endif
				}
			}
			info->lock_state = 0;
			info->lock_critical_state = 0;
			env_set("lock_state", "green");
			fastboot_okay(NULL, response);
		} else {
			printf("unlock_ability is 0, can not unlock, please set it in android setting\n");
			fastboot_response("FAIL", response, "%s", "unlock_ability is 0, can not unlock");
		}
	} else if (!strcmp_l1("lock", cmd)) {
		if (info->lock_state == 0 ) {
			char *avb_s;
			avb_s = env_get("avb2");
			if (avb_s == NULL) {
				run_command("get_avb_mode;", 0);
				avb_s = env_get("avb2");
			}
			printf("avb2: %s\n", avb_s);
			if (strcmp(avb_s, "1") == 0) {
#ifdef CONFIG_AML_ANTIROLLBACK
				if (avb_lock()) {
					printf("lock failed!\n");
				} else {
					if (-1 == rc) {
						printf("locking device.  Erasing data partition!\n");
						run_command("store erase data 0 0", 0);
					} else {
						printf("locking device.  Erasing userdata partition!\n");
						run_command("store erase userdata 0 0", 0);
					}
					printf("unlocking device.  Erasing metadata partition!\n");
					run_command("store erase metadata 0 0", 0);
				}
#else
				if (-1 == rc) {
					printf("locking device.  Erasing data partition!\n");
					run_command("store erase data 0 0", 0);
				} else {
					printf("locking device.  Erasing userdata partition!\n");
					run_command("store erase userdata 0 0", 0);
				}
				printf("unlocking device.  Erasing metadata partition!\n");
				run_command("store erase metadata 0 0", 0);

#endif
			}
		}
		info->lock_state = 1;
		env_set("lock_state", "orange");
		fastboot_okay(NULL, response);
	} else {
		printf("unknown variable: %s\n", cmd);
		fastboot_response("FAIL", response, "%s", "Variable not implemented");
	}

	sprintf(lock_d, "%d%d%d0%d%d%d0", info->version_major, info->version_minor, info->unlock_ability, info->lock_state, info->lock_critical_state, info->lock_bootloader);
	printf("lock_d state: %s\n", lock_d);
	env_set("lock", lock_d);
	run_command("defenv_reserv; saveenv;", 0);
	free(info);
	return;
}
#endif// #if !CONFIG_IS_ENABLED(NO_FASTBOOT_FLASHING)

/**
 * reboot_bootloader() - Sets reboot bootloader flag.
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 */
static void reboot_bootloader(char *cmd_parameter, char *response)
{
	fastboot_okay(NULL, response);
}

/**
 * reboot_fastboot() - Sets reboot fastboot flag.
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 */
static void reboot_fastboot(char *cmd_parameter, char *response)
{
	fastboot_okay(NULL, response);
}

static void oem_cmd(char *cmd_parameter, char *response)
{
	char *cmd;
	int i = 0, len = 0, j = 0;
	char cmd_str[FASTBOOT_RESPONSE_LEN];
	printf("oem cmd_parameter: %s\n", cmd_parameter);
	cmd = cmd_parameter;
	strsep(&cmd, " ");
	printf("To run cmd[%s]\n", cmd);

	len = strlen(cmd);
	for (i = 0; i < len; i++) {
		if (cmd[i] != '\'') {
			cmd_str[j++] = cmd[i];
		}
	}
	cmd_str[j] = '\0';
	printf("cmd_str2: %s\n", cmd_str);

	run_command(cmd_str, 0);

	fastboot_okay(NULL, response);
	return;
}


#if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT)
/**
 * oem_format() - Execute the OEM format command
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 */
static void oem_format(char *cmd_parameter, char *response)
{
	char cmdbuf[32];

	if (!env_get("partitions")) {
		fastboot_fail("partitions not set", response);
	} else {
		sprintf(cmdbuf, "gpt write mmc %x $partitions",
			CONFIG_FASTBOOT_FLASH_MMC_DEV);
		if (run_command(cmdbuf, 0))
			fastboot_fail("", response);
		else
			fastboot_okay(NULL, response);
	}
}
#endif