// SPDX-License-Identifier: GPL-2.0+
/*
 *
 */
#include <common.h>
#include <command.h>
#include <console.h>
#include <environment.h>
#include <malloc.h>
#include <mmc.h>
#include <linux/math64.h>
#include <part.h>
#include <fat.h>
#include <fs.h>
#include <asm/arch/ark-common.h>
#define BDEVNAME_SIZE		32
#define PAGE_SIZE			(2048)
#define CHECKDATA_ERROR		2
typedef unsigned long long sector_t;
extern struct SYS_INFO sys_info;
struct cmdline_subpart {
	char name[BDEVNAME_SIZE];/* partition name, such as 'rootfs' */
	sector_t from;
	sector_t size;
	struct cmdline_subpart *next_subpart;
};
struct cmdline_parts {
	char name[BDEVNAME_SIZE]; /* block device, such as 'mmcblk0' */
	unsigned int nr_subparts;
	struct cmdline_subpart *subpart;
	struct cmdline_parts *next_parts;
};
static struct cmdline_parts *bdev_parts;
static unsigned long long memparse(const char *ptr, char **retptr)
{
	char *endptr;   /* local pointer to end of parsed string */
	unsigned long long ret = simple_strtoull(ptr, &endptr, 0);
	switch (*endptr) {
	case 'E':
	case 'e':
		ret <<= 10;
	case 'P':
	case 'p':
		ret <<= 10;
	case 'T':
	case 't':
		ret <<= 10;
	case 'G':
	case 'g':
		ret <<= 10;
	case 'M':
	case 'm':
		ret <<= 10;
	case 'K':
	case 'k':
		ret <<= 10;
		endptr++;
	default:
		break;
	}
	if (retptr)
		*retptr = endptr;
	return ret;
}
static int parse_subpart(struct cmdline_subpart **subpart, char *partdef)
{
	int ret = 0;
	struct cmdline_subpart *new_subpart;
	*subpart = NULL;
	new_subpart = malloc(sizeof(struct cmdline_subpart));
	if (!new_subpart)
		return -ENOMEM;
	memset(new_subpart, 0, sizeof(struct cmdline_subpart));
	if (*partdef == '-') {
		new_subpart->size = (sector_t)(~0ULL);
		partdef++;
	} else {
		new_subpart->size = (sector_t)memparse(partdef, &partdef);
		if (new_subpart->size < (sector_t)PAGE_SIZE) {
			pr_warn("cmdline partition size is invalid.");
			ret = -EINVAL;
			goto fail;
		}
	}
	if (*partdef == '@') {
		partdef++;
		new_subpart->from = (sector_t)memparse(partdef, &partdef);
	} else {
		new_subpart->from = (sector_t)(~0ULL);
	}
	if (*partdef == '(') {
		int length;
		char *next = strchr(++partdef, ')');
		if (!next) {
			pr_warn("cmdline partition format is invalid.");
			ret = -EINVAL;
			goto fail;
		}
		length = min_t(int, next - partdef,
					sizeof(new_subpart->name) - 1);
		strncpy(new_subpart->name, partdef, length);
		new_subpart->name[length] = '\0';
		partdef = ++next;
	} else
		new_subpart->name[0] = '\0';
	*subpart = new_subpart;
	return 0;
fail:
	free(new_subpart);
	return ret;
}
static void free_subpart(struct cmdline_parts *parts)
{
	struct cmdline_subpart *subpart;
	while (parts->subpart) {
		subpart = parts->subpart;
		parts->subpart = subpart->next_subpart;
		free(subpart);
	}
}
static int parse_parts(struct cmdline_parts **parts, const char *bdevdef)
{
	int ret = -EINVAL;
	char *next;
	int length;
	struct cmdline_subpart **next_subpart;
	struct cmdline_parts *newparts;
	char buf[BDEVNAME_SIZE + 32 + 4];
	*parts = NULL;
	newparts = malloc(sizeof(struct cmdline_parts));
	if (!newparts)
		return -ENOMEM;
	memset(newparts, 0, sizeof(struct cmdline_parts));
	next = strchr(bdevdef, ':');
	if (!next) {
		pr_warn("cmdline partition has no block device.");
		goto fail;
	}
	length = min_t(int, next - bdevdef, sizeof(newparts->name) - 1);
	strncpy(newparts->name, bdevdef, length);
	newparts->name[length] = '\0';
	newparts->nr_subparts = 0;
	next_subpart = &newparts->subpart;
	while (next && *(++next)) {
		bdevdef = next;
		next = strchr(bdevdef, ',');
		length = (!next) ? (sizeof(buf) - 1) :
			min_t(int, next - bdevdef, sizeof(buf) - 1);
		strncpy(buf, bdevdef, length);
		buf[length] = '\0';
		ret = parse_subpart(next_subpart, buf);
		if (ret)
			goto fail;
		newparts->nr_subparts++;
		next_subpart = &(*next_subpart)->next_subpart;
	}
	if (!newparts->subpart) {
		pr_warn("cmdline partition has no valid partition.");
		ret = -EINVAL;
		goto fail;
	}
	*parts = newparts;
	return 0;
fail:
	free_subpart(newparts);
	free(newparts);
	return ret;
}
void cmdline_parts_free(struct cmdline_parts **parts)
{
	struct cmdline_parts *next_parts;
	while (*parts) {
		next_parts = (*parts)->next_parts;
		free_subpart(*parts);
		free(*parts);
		*parts = next_parts;
	}
}
static int cmdline_parts_parse(struct cmdline_parts **parts, const char *cmdline)
{
	int ret;
	char *buf;
	char *pbuf;
	char *next;
	struct cmdline_parts **next_parts;
	*parts = NULL;
	next = pbuf = buf = strdup(cmdline);
	if (!buf)
		return -ENOMEM;
	next_parts = parts;
	while (next && *pbuf) {
		next = strchr(pbuf, ';');
		if (next)
			*next = '\0';
		ret = parse_parts(next_parts, pbuf);
		if (ret)
			goto fail;
		if (next)
			pbuf = ++next;
		next_parts = &(*next_parts)->next_parts;
	}
	if (!*parts) {
		pr_warn("cmdline partition has no valid partition.");
		ret = -EINVAL;
		goto fail;
	}
	ret = 0;
done:
	free(buf);
	return ret;
fail:
	cmdline_parts_free(parts);
	goto done;
}
static int emmcparts_init(struct mmc *mmc)
{
	static int emmcparts_has_init = 0;
	const char *cmdline = CONFIG_EMMCPARTS_DEFAULT;
	if (emmcparts_has_init)
		return 0;
	if (cmdline && cmdline_parts_parse(&bdev_parts, cmdline)) {
		bdev_parts = NULL;
		return -1;
	}
	sector_t from = 0;
	sector_t disk_size = mmc->capacity;
	struct cmdline_subpart *subpart;
	for (subpart = bdev_parts->subpart; subpart; subpart = subpart->next_subpart) {
		if (subpart->from == (sector_t)(~0ULL))
			subpart->from = from;
		else
			from = subpart->from;
		if (from >= disk_size)
			break;
		if (subpart->size > (disk_size - from))
			subpart->size = disk_size - from;
		pr_debug("subpart %s from 0x%llx, size 0x%llx.\n", subpart->name, subpart->from, subpart->size);
		from += subpart->size;
	}
	emmcparts_has_init = 1;
	return 0;
}
static struct mmc *init_emmc_device(void)
{
	struct mmc *mmc;
	int dev = simple_strtoul(CONFIG_EMMC_DEV_PART, NULL, 10);
	mmc = find_mmc_device(dev);
	if (!mmc) {
		printf("no emmc device at slot %x\n", dev);
		return NULL;
	}
	if (mmc_init(mmc))
		return NULL;
	emmcparts_init(mmc);
	return mmc;
}
int get_part(const char *partname, loff_t *off, loff_t *size, loff_t *maxsize)
{
	struct cmdline_subpart *subpart;
	if (!bdev_parts) {
		printf("not found emmc partition table.\n");
		return -1;
	}
	for (subpart = bdev_parts->subpart; subpart; subpart = subpart->next_subpart) {
		if (!strcmp(subpart->name, partname)) {
			*off = subpart->from;
			*size = subpart->size;
			*maxsize = subpart->size;
			return 0;
		}
	}
	printf("not found part %s.\n", partname);
	return -1;
}
static int emmc_arg_off(const char *arg, loff_t *off, loff_t *size,
		loff_t *maxsize, uint64_t chipsize)
{
	if (!str2off(arg, off))
		return get_part(arg, off, size, maxsize);
	if (*off >= chipsize) {
		puts("Offset exceeds device limit\n");
		return -1;
	}
	*maxsize = chipsize - *off;
	*size = *maxsize;
	return 0;
}
static int emmc_arg_off_size(int argc, char *const argv[], loff_t *off,
			loff_t *size, uint64_t chipsize)
{
	loff_t maxsize;
	int ret;
	if (argc == 0) {
		*off = 0;
		*size = chipsize;
		goto print;
	}
	ret = emmc_arg_off(argv[0], off, size, &maxsize, chipsize);
	if (ret)
		return ret;
	if (argc == 1)
		goto print;
	if (!str2off(argv[1], size)) {
		printf("'%s' is not a number\n", argv[1]);
		return -1;
	}
	if (*size > maxsize) {
		puts("Size exceeds partition or device limit\n");
		return -1;
	}
print:
	if (*size == chipsize)
		puts("whole chip\n");
	else
		printf("offset 0x%llx, size 0x%llx\n",
				(unsigned long long)*off, (unsigned long long)*size);
	return 0;
}
static int do_emmc_read(cmd_tbl_t *cmdtp, int flag,
				int argc, char * const argv[])
{
	struct mmc *mmc;
	loff_t off, size;
	u32 blk, cnt, n;
	void *addr;
	if (argc != 3 && argc != 4)
		return CMD_RET_USAGE;
	addr = (void *)simple_strtoul(argv[1], NULL, 16);
	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
	emmc_arg_off_size(argc - 2, argv + 2, &off, &size, mmc->capacity);
	struct blk_desc *blkdesc = mmc_get_blk_desc(mmc);
	if (off & (blkdesc->blksz - 1)) {
		printf("off(0x%llx) is not align to blksz(%lu).\n", off, blkdesc->blksz);
		return CMD_RET_FAILURE;
	}
	blk = div_u64(off, blkdesc->blksz);
	u32 remainder;
	cnt = div_u64_rem(size, blkdesc->blksz, &remainder);
	if (remainder) cnt += 1;
	printf("EMMC read: block # %d, count %d ... ",
			blk, cnt);
	n = blk_dread(mmc_get_blk_desc(mmc), blk, cnt, addr);
	printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
	return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
}
#if CONFIG_IS_ENABLED(MMC_WRITE)
static int do_emmc_write(cmd_tbl_t *cmdtp, int flag,
			int argc, char * const argv[])
{
	struct mmc *mmc;
	loff_t off, size;
	u32 blk, cnt, n;
	void *addr;
	if (argc != 3 && argc != 4)
		return CMD_RET_USAGE;
	addr = (void *)simple_strtoul(argv[1], NULL, 16);
	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
	emmc_arg_off_size(argc - 2, argv + 2, &off, &size, mmc->capacity);
	struct blk_desc *blkdesc = mmc_get_blk_desc(mmc);
	if (off & (blkdesc->blksz-1)) {
		printf("off(0x%llx) is not align to blksz(%lu).\n", off, blkdesc->blksz);
		return CMD_RET_FAILURE;
	}
	blk = div_u64(off, blkdesc->blksz);
	u32 remainder;
	cnt = div_u64_rem(size, blkdesc->blksz, &remainder);
	if (remainder) cnt += 1;
	printf("EMMC write: block # %d, count %d ... ",
			blk, cnt);
	if (mmc_getwp(mmc) == 1) {
		printf("Error: card is write protected!\n");
		return CMD_RET_FAILURE;
	}
	n = blk_dwrite(mmc_get_blk_desc(mmc), blk, cnt, addr);
	printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
	return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
}
static int do_emmc_erase(cmd_tbl_t *cmdtp, int flag,
			int argc, char * const argv[])
{
	struct mmc *mmc;
	loff_t off, size;
	u32 blk, cnt, n;
	int args = 2;
	if (argc > 3)
		return CMD_RET_USAGE;
	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
	if (argv[0][5] != 0) {
		if (!strcmp(&argv[0][5], ".part")) {
			args = 1;
		} else if (!strcmp(&argv[0][5], ".chip")) {
			args = 0;
		} else {
			goto usage;
		}
	}
	emmc_arg_off_size(args, argv + 1, &off, &size, mmc->capacity);
	struct blk_desc *blkdesc = mmc_get_blk_desc(mmc);
	if (off & (blkdesc->blksz-1)) {
		printf("off(0x%llx) is not align to blksz(%lu).\n", off, blkdesc->blksz);
		return CMD_RET_FAILURE;
	}
	blk = div_u64(off, blkdesc->blksz);
	u32 remainder;
	cnt = div_u64_rem(size, blkdesc->blksz, &remainder);
	if (remainder) cnt += 1;
	printf("EMMC erase: block # %d, count %d ... ",
			blk, cnt);
	if (mmc_getwp(mmc) == 1) {
		printf("Error: card is write protected!\n");
		return CMD_RET_FAILURE;
	}
	n = blk_derase(mmc_get_blk_desc(mmc), blk, cnt);
	printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
	return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
usage:
	return CMD_RET_USAGE;
}
#endif
static cmd_tbl_t cmd_mmc[] = {
	U_BOOT_CMD_MKENT(read, 4, 1, do_emmc_read, "", ""),
#if CONFIG_IS_ENABLED(MMC_WRITE)
	U_BOOT_CMD_MKENT(write, 4, 0, do_emmc_write, "", ""),
	U_BOOT_CMD_MKENT(erase, 3, 0, do_emmc_erase, "", ""),
#endif
};
static int do_emmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	cmd_tbl_t *cp;
	cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
	/* Drop the mmc command */
	argc--;
	argv++;
	if (cp == NULL || argc > cp->maxargs)
		return CMD_RET_USAGE;
	if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
		return CMD_RET_SUCCESS;
	return cp->cmd(cmdtp, flag, argc, argv);
}
#ifdef CONFIG_SYS_LONGHELP
static char emmc_help_text[] =
	"emmc read - addr off|partition size\n"
	"emmc write - addr off|partition size\n"
	"    read/write 'size' bytes starting at offset 'off'\n"
	"    to/from memory address 'addr'.\n"
	"emmc erase off size - erase 'size' bytes "
	"from offset 'off'\n"
	"emmc erase.part partition - erase entire partition'\n"
	"emmc erase.chip - erase entire chip'\n"
	"";
#endif
U_BOOT_CMD(
	emmc, CONFIG_SYS_MAXARGS, 1, do_emmcops,
	"EMMC sub-system", emmc_help_text
);
/**
 * Format and print out a partition list for each device from global device
 * list.
 */
static void list_partitions(void)
{
	struct cmdline_subpart *subpart;
	int part_num = 0;
	printf("\ndevice %s, # parts = %d\n",
		bdev_parts->name, bdev_parts->nr_subparts);
	printf(" #: name\t\tsize\t\toffset\n");
	for (subpart = bdev_parts->subpart; subpart; subpart = subpart->next_subpart) {
		printf("%2d: %-20s0x%08llx\t0x%08llx\n",
				part_num++, subpart->name, subpart->size,
				subpart->from);
	}
}
static int do_emmcparts(cmd_tbl_t *cmdtp, int flag, int argc,
			char * const argv[])
{
	struct mmc *mmc;
	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
	if (!bdev_parts) {
		printf("not found emmc partition table.\n");
		return CMD_RET_FAILURE;
	}

	list_partitions();
	return 0;
}
#ifdef CONFIG_SYS_LONGHELP
static char emmcparts_help_text[] =
	"\n"
	"    - list emmc partition table\n"
	"";
#endif
U_BOOT_CMD(
	emmcparts,	1,	0,	do_emmcparts,
	"list emmc partitions", emmcparts_help_text
);
void get_Emmc_Parition_info(const char *filename,loff_t *off,loff_t *rtsize,loff_t *maxsize)
{
	char cmd[128];
	unsigned int pos = 0,i;
	unsigned int size = 0;
	unsigned int leftsize ;
	struct mmc *mmc;

	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
	if(get_part(filename,off,rtsize, maxsize) == 0)
		printf("get Emmc part info filename %s!!\n",filename);
	printf("off = 0x%llx ,rtsize = 0x%llx,maxsize = 0x%llx\n",*off,*rtsize,*maxsize);
	return 0;
}
#if 1
#define FAT_READ_SIZE   0x2000000
#define ROOTFS_SIZE  	0x1f400000
static int do_update_rootfs (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	unsigned int rootfsize = 0;
	char cmd[128];
	unsigned int pos = 0;
	unsigned int size = 0;
	unsigned int i = 0;
	unsigned int leftsize,k;
	struct mmc *mmc;
	loff_t off  = 0;
	loff_t rtsize = 0;
	loff_t maxsize= 0;
	unsigned int count = 0;
	unsigned int ret = 0;
	unsigned int file_size = 0;
	unsigned int *srcdata = (unsigned int *)(env_get_hex("loadaddr", 0));
	unsigned int *dstdata = (unsigned int *)(env_get_hex("cmploadaddr", 0));
	unsigned int checksum = 0;
	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
	printf("argv[0] %s , argv[1] %s\n",argv[0],argv[1]);
	if(get_part(argv[1],&off, &rtsize, &maxsize) == 0)
		printf("get Emmc part info argv[1] %s!!\n",argv[1]);
	printf("off = 0x%llx ,rtsize = 0x%llx,maxsize = 0x%llx\n",off,rtsize,maxsize);
#if 1
	sprintf(cmd, "fatsize %s %s rootfs.ext2", env_get("update_dev_type"), env_get("update_dev_part"));
	printf("cmd = %s\n",cmd);
	ret = run_command(cmd, 0);
	if(ret)
		return 2;
	mdelay(100);
	rootfsize = env_get_hex("filesize", 0);
	printf("rootfsize = 0x%x\n",rootfsize);
	if(rootfsize == 0)
	{
		printf("Error:rootfs file maybe not in device!!!\n");
		return 2;
	}
#endif
	size = FAT_READ_SIZE;
	count = 55/((rootfsize/size)+1);
	for(pos = 0,i = 1;pos < rootfsize;i++)
	{
		sprintf(cmd, "fatload %s %s %s rootfs.ext2 0x%x 0x%x", env_get("update_dev_type"), env_get("update_dev_part"), env_get("loadaddr"),size,pos);
		printf("cmd = %s\n",cmd);
		ret = run_command(cmd, 0);
		if(ret)
			return ret;
		mdelay(100);
		file_size = env_get_ulong("filesize", 16, 0x2000);
		if(file_size == 0)
			break;
		sprintf(cmd, "emmc erase 0x%llx 0x%x",off,size);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(100);
		sprintf((char *)cmd,"disconfig %d",(40+i*count));
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		sprintf(cmd, "emmc write %s 0x%llx 0x%x",env_get("loadaddr"),off,file_size);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(100);
		sprintf(cmd, "emmc read %s 0x%llx 0x%x",env_get("cmploadaddr"),off,file_size);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(100);

		checksum = crc32(checksum, (const unsigned char *)dstdata, file_size);
		off = off + size;
		pos += size;
		if(file_size < FAT_READ_SIZE)
		{
			printf("data is over!!!\n");
			break;
		}
	}
	sprintf(cmd, "setenv rootfssize 0x%x ",rootfsize);
	printf("cmd = %s\n",cmd);
	run_command(cmd, 0);
	printf(">>>rootfs crc value:0x%x\n",checksum);
	ret = ark_check_data_from_partition("rootfs",checksum);
	if(ret)
	{
		printf("checksum data error!!!\n");
		return 1;
	}
	return 0;
}
U_BOOT_CMD(
	updaterootfs,	6,	0,	do_update_rootfs,
	"load binary file from a dos filesystem",
	"<interface> <dev[:part]> <addr> <filename> [<bytes>]\n"
	"- write file 'filename' from the address 'addr' in RAM\n"
	"to 'dev' on 'interface'"
);
static int do_update_rootfs_from_ota(char *partition_name, char *file_name)
{
	unsigned int rootfsize = 0;
	char cmd[128];
	unsigned int pos = 0,i = 0,k;
	unsigned int size = 0;
	unsigned int leftsize ;
	struct mmc *mmc;
	loff_t off  = 0;
	loff_t rtsize = 0;
	loff_t maxsize= 0;
	unsigned int ret = 0;
	unsigned int file_size = 0;
	unsigned int count=0,step = 0;
	unsigned int *srcdata = (unsigned int *)(env_get_hex("loadaddr", 0));
	unsigned int *dstdata = (unsigned int *)(env_get_hex("cmploadaddr", 0));
	unsigned int checksum = 0;

	mmc = init_emmc_device();
	if (!mmc)
		return CMD_RET_FAILURE;
		printf("partition_name %s ,file_name %s\n",partition_name,file_name);
	if(get_part(partition_name,&off, &rtsize, &maxsize) == 0)
		printf("get Emmc part info partition_name %s!!\n",partition_name);
	size = FAT_READ_SIZE;
	count = 55/((ROOTFS_SIZE/size)+1);
	while(1)
	{
		i++;
		sprintf(cmd, "fatload emmc ota %s %s 0x%x 0x%x",env_get("loadaddr"),file_name,size,pos);
		printf("cmd = %s\n",cmd);
		ret = run_command(cmd, 0);
		if(ret)
		{
			printf("Error:rootfs file maybe not in ota partition!!!\n");
			 return 2;
		}
		file_size = env_get_ulong("filesize", 16, 0x2000);
		if(file_size == 0)
		{
			printf("Error:rootfs file maybe not in ota partition!!!\n");
			return 2;
		}
		sprintf(cmd, "emmc erase 0x%llx 0x%x",off,size);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(200);
		step = (40+i*5);
		if(step>95)
			step = 95;
		sprintf((char *)cmd,"disconfig %d",step);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(200);
		sprintf(cmd, "emmc write %s 0x%llx 0x%x",env_get("loadaddr"),off,file_size);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(200);
		sprintf(cmd, "emmc read %s 0x%llx 0x%x",env_get("cmploadaddr"),off,file_size);
		printf("cmd = %s\n",cmd);
		run_command(cmd, 0);
		mdelay(100);
		checksum = crc32(checksum, (const unsigned char *)dstdata, file_size);
		off = off + size;
		pos += size;
		rootfsize = rootfsize + size;
		if(file_size < FAT_READ_SIZE)
			break;
	}
	sprintf(cmd, "setenv rootfssize 0x%x ",rootfsize);
	printf("cmd = %s\n",cmd);
	run_command(cmd, 0);
	printf(">>>>ota rootfs crc value:0x%x\n",checksum);
	ret = ark_check_data_from_partition("rootfs",checksum);
	if(ret)
		return 1;
	return 0;
}

static int get_data_from_ota(char *file_name)
{
	int ret = -1;
	unsigned int file_size,crc_src;
	char cmd[128] = { 0 };
	unsigned int *srcdata = (unsigned int *)(env_get_hex("loadaddr", 0));
	sprintf(cmd, "fatload emmc ota %s %s",env_get("loadaddr"), file_name);
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if(ret)
	{
		printf("Load %s from ota error!!\n",file_name);
		return 1;
	}
	file_size = env_get_ulong("filesize", 16, 0x2000);
	crc_src = crc32(0, (const unsigned char *)srcdata, file_size);
	ret = ark_check_data_from_devide(file_name,crc_src);
	if(ret)
	{
		printf("check data %s from ota crc error!!\n",file_name);
		return 1;
	}
	printf("check ota partition crc ok!!\n");
	return 0;
}

static int burn_data_2_emmc_partition(char *partition_name)
{
	char cmd[128] = { 0 };
	int ret = -1;
	int file_size = 0;
	unsigned int crc_des = 0;
	unsigned int *srcdata = (unsigned int *)(env_get_hex("loadaddr", 0));
	unsigned int *dstdata = (unsigned int *)(env_get_hex("cmploadaddr", 0));
	sprintf(cmd, "emmc erase.part %s", partition_name);
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if (ret)
		return ret;
	file_size = env_get_ulong("filesize", 16, 0x2000);
	sprintf(cmd, "emmc write %s %s 0x%x", env_get("loadaddr"), partition_name, file_size);
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if(ret)
	{
		printf("emmc write data error!!!\n");
		return 1;
	}
	sprintf(cmd, "emmc read %s %s 0x%x",env_get("cmploadaddr"),partition_name, file_size);
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if(ret)
	{
		printf("emmc write data error!!!\n");
		return 1;
	}
	crc_des = crc32(0, (const unsigned char *)dstdata, file_size);
	ret  = ark_check_data_from_partition(partition_name,crc_des);
	if(ret)
		return 1;
	printf("crc %s data OK!!!\n",partition_name);
	return 0;
}
static int ark_update_emmc_partition(char *partition_name, char *file_name)
{
	int ret;
	printf("\r\n****** update %s from ota:%s .....\r\n",partition_name,file_name);
	ret = get_data_from_ota(file_name);
	if (!ret) {
		return burn_data_2_emmc_partition(partition_name);
	}
	return ret;
}
static int ark_update_emmc_rootfs_from_ota(char *partition_name, char *file_name)
{
	char cmd[32];
	unsigned int ret = 0;
	printf("\r\n****** update %s from ota:%s .....\r\n",partition_name,file_name);
	ret = do_update_rootfs_from_ota(partition_name,file_name);
	return ret;
}

static int get_crc_data_from_ota(char *file_name)
{
	int ret = -1;
	unsigned int file_size;
	char cmd[128] = { 0 };
	unsigned int *srcdata = (unsigned int *)(env_get_hex("loadaddr", 0));
	memset(&sys_info, 0, sizeof(sys_info));
	printf("file_name=%s\n", file_name);
	sprintf(cmd, "fatload emmc ota %s %s",env_get("loadaddr"), file_name);
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if(ret)
		return 1;
	file_size = env_get_ulong("filesize", 16, 0x2000);
	memcpy(&sys_info, srcdata, file_size);
//	printf("uboot_crc 		  = 0x%x\n",sys_info.uboot_crc);
//	printf("fdt_crc			  = 0x%x\n",sys_info.fdt_crc);
//	printf("zImage_crc 		  = 0x%x\n",sys_info.zImage_crc);
//	printf("rootfs_crc		  = 0x%x\n",sys_info.rootfs_crc);
//	printf("ubootspl_crc	  = 0x%x\n",sys_info.ubootspl_crc);
//	printf("bootanimation_crc = 0x%x\n",sys_info.bootanimation_crc);
//	printf("bootlogo_crc	  = 0x%x\n",sys_info.bootlogo_crc);
	return 0;
}

#define ARK1668_UPDATE_MAGIC	"ada7f0c6-7c86-11e9-8f9e-2a86e4085a59"
int do_update_from_ota(cmd_tbl_t * cmdtp, int flag, int argc, char *const argv[])
{
	char cmd[32];
	unsigned int index = 0;
	unsigned int ret = 0;
	unsigned int loadaddr = 0;
	unsigned char update_fdt_name[32];
	unsigned char flag_partiton = 0 ;
	static char curr_partition[32];
	unsigned int dis_pos_x  = 0;
	unsigned int dis_pos_y  = 0;
	unsigned int resetuboot = 0;
	unsigned int fdtsize = 0;
	unsigned int kernelsize = 0;
	sprintf(cmd, "mmc dev %s",env_get("emmc_dev_part"));
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	loadaddr = env_get_hex("loadaddr", 0);
	if (loadaddr)
		memset((void*)loadaddr, 0, strlen(ARK1668_UPDATE_MAGIC));
	sprintf(cmd, "fatload emmc ota %s %s ", env_get("loadaddr"),"update-magic");
	run_command(cmd, 0);
	if (loadaddr && !memcmp((void *)loadaddr, ARK1668_UPDATE_MAGIC, strlen(ARK1668_UPDATE_MAGIC))) {
		printf("ARK1668_UPDATE_MAGIC CHECK OK!!\n");
	} else {
		printf("Wrong update magic, do not update from emmc.\n");
		goto bootoldsys;
	}
	mdelay(20);
	sprintf(update_fdt_name, "%s", env_get("boardfdt"));
	env_set("updata_status", "ota");
	resetuboot = env_get_hex("ubootreset", 0);
	mdelay(50);
//	curr_partition  = env_get("updata_from_part");
	sprintf(curr_partition, "%s", env_get("updata_from_part"));
	mdelay(20);
	fdtsize = env_get_hex("fdtsize", 0);
	kernelsize = env_get_hex("kernelsize", 0);
	mdelay(20);
	run_command("env default -f -a", 0);
	mdelay(500);
	if(!strcmp(curr_partition, "A"))
	{
		env_set("updata_from_part", "A");
		flag_partiton = 1;
	}
	else if(!strcmp(curr_partition, "B"))
	{
		env_set("updata_from_part", "B");
		flag_partiton = 0;
	}
	else
	{
		env_set("updata_from_part", "A");
		flag_partiton = 0;
	}
	printf("curr_partition %s,resetuboot = %d,update_fdt_name %s \n",curr_partition,resetuboot,update_fdt_name);
	mdelay(20);
	sprintf((char *)cmd,"disconfig 0");
	run_command(cmd, 0);
	get_crc_data_from_ota("crcdata.bin");

	dis_pos_x = 6;
	dis_pos_y = 20;
//**** update from update ubootspl
	ret = ark_update_emmc_partition("bootstrap", "ubootspl.bin");
	mdelay(30);
	if(!ret)
	{
		sprintf(cmd, "setenv bootstrapsize %s",env_get("filesize"));
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 5");
		run_command(cmd, 0);
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootstrap",0);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else
	{
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootstrap",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
//	**** update from update uboot
	ret = ark_update_emmc_partition("bootloader", "u-boot.img");
	mdelay(30);
	if(!ret)
	{
		sprintf(cmd, "setenv bootloadersize %s",env_get("filesize"));
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 10");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootloader",0);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		if(resetuboot == 0)
		{
			env_set("ubootreset", "1");
			env_set("update_from_ota", "yes");
			sprintf(cmd, "setenv updata_from_part %s",curr_partition);
			printf(">>>>>>>cmd=%s\n",cmd);
			run_command(cmd, 0);
			mdelay(10);
			if(!strcmp(curr_partition, "A"))
			{
				env_set("updata_from_part", "A");
				env_set("kernel_part", "kernel");
				env_set("fdt_part", "fdt");
				env_set("rootfs_part", "rootfs");
				env_set("emmcroot", "/dev/mmcblk0p10 ro");
			}
			else if(!strcmp(curr_partition, "B"))
			{
				env_set("updata_from_part", "B");
				env_set("kernel_part", "kernel_b");
				env_set("fdt_part", "fdt_b");
				env_set("rootfs_part", "rootfs_b");
				env_set("emmcroot", "/dev/mmcblk0p14 ro");
			}
			sprintf(cmd, "setenv fdtsize 0x%x",fdtsize);
			printf(">>>>>>>cmd=%s\n",cmd);
			run_command(cmd, 0);
			mdelay(10);
			sprintf(cmd, "setenv kernelsize 0x%x",kernelsize);
			printf(">>>>>>>cmd=%s\n",cmd);
			run_command(cmd, 0);
			mdelay(10);
			run_command("saveenv", 0);
			mdelay(100);
			run_command("reset", 0);
			while(1);
		}
		env_set("ubootreset", "0");
		mdelay(20);
	}
	else
	{
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootloader",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
//**** update from update fdt
	if (flag_partiton == 0)
		ret = ark_update_emmc_partition("fdt", update_fdt_name);
	else
		ret = ark_update_emmc_partition("fdt_b", update_fdt_name);
	mdelay(30);
	if(!ret)
	{
		if(flag_partiton == 0)
			sprintf(cmd, "setenv fdtsize_a %s",env_get("filesize"));
		else
			sprintf(cmd, "setenv fdtsize_b %s",env_get("filesize"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 15");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		if (flag_partiton == 0)
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"fdt",0);
		else
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"fdt_b",0);

		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else
	{
		dis_pos_y = dis_pos_y + 20;
		if (flag_partiton == 0)
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"fdt",1);
		else
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"fdt_b",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
//**** update from update kernel
	if (flag_partiton == 0)
		ret = ark_update_emmc_partition("kernel", "zImage");
	else
		ret = ark_update_emmc_partition("kernel_b", "zImage");
	mdelay(30);
	if(!ret)
	{
		if(flag_partiton == 0)
			sprintf(cmd, "setenv kernelsize_a %s",env_get("filesize"));
		else
			sprintf(cmd, "setenv kernelsize_b %s",env_get("filesize"));
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 25");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		if (flag_partiton == 0)
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"kernel",0);
		else
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"kernel_b",0);

		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else
	{
		dis_pos_y = dis_pos_y + 20;
		if (flag_partiton == 0)
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"kernel",1);
		else
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"kernel_b",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
#if 0
//**** update from update bootanimation
	ret = ark_update_emmc_partition("bootanimation", "bootanimation");
	mdelay(30);
	if(!ret)
	{

		sprintf(cmd, "setenv bootanimationsize %s",env_get("filesize"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 30");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootanimation",0);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else
	{
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootanimation",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
//	**** update from update reversingtrack
	ret = ark_update_emmc_partition("reversingtrack", "reversingtrack");
	mdelay(30);
	if(!ret)
	{
		sprintf(cmd, "setenv reversingtracksize %s",env_get("filesize"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 35");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"reversingtrack",0);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else
	{
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"reversingtrack",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
#endif
//	**** update from update uboot back
	ret = ark_update_emmc_partition("bootloader_bak", "u-boot.img");
	mdelay(30);
	if(!ret)
	{
		sprintf(cmd, "setenv bootloadersize %s",env_get("filesize"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf((char *)cmd,"disconfig 40");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootloader_bak",0);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else
	{
		dis_pos_y = dis_pos_y + 20;
		sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"bootloader_bak",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
//	**** update from update rootfs
	if (flag_partiton == 0)
		ret = ark_update_emmc_rootfs_from_ota("rootfs", "rootfs.ext2");
	else
		ret = ark_update_emmc_rootfs_from_ota("rootfs_b", "rootfs.ext2");
	if(!ret)
	{
		sprintf((char *)cmd,"disconfig 95");
		run_command(cmd, 0);
		dis_pos_y = dis_pos_y + 20;
		if (flag_partiton == 0)
			sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"rootfs",0);
		else
			sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"rootfs_b",0);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
	else if(ret != 2)
	{
		dis_pos_y = dis_pos_y + 20;
		if (flag_partiton == 0)
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"rootfs",1);
		else
			 sprintf((char *)cmd,"disstring %d %d %s %d",dis_pos_x,dis_pos_y,"rootfs_b",1);
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
		goto bootoldsys;
	}
	if(flag_partiton == 1)
	{
		env_set("updata_from_part", "B");
		env_set("kernel_part", "kernel_b");
		env_set("fdt_part", "fdt_b");
		env_set("rootfs_part", "rootfs_b");
		env_set("emmcroot", "/dev/mmcblk0p14 ro");
		sprintf(cmd, "setenv fdtsize %s",env_get("fdtsize_b"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf(cmd, "setenv kernelsize %s",env_get("kernelsize_b"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
	}
	else if(flag_partiton == 0)
	{
		env_set("updata_from_part", "A");
		env_set("kernel_part", "kernel");
		env_set("fdt_part", "fdt");
		env_set("rootfs_part", "rootfs");
		env_set("emmcroot", "/dev/mmcblk0p10 ro");
		sprintf(cmd, "setenv fdtsize %s",env_get("fdtsize_a"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf(cmd, "setenv kernelsize %s",env_get("kernelsize_a"));
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
	}
	env_set("updata_status", "ok");
	mdelay(30);
	env_set("need_update", "no");
	mdelay(30);
	env_set("update_from_ota", "no");
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	mdelay(30);
	sprintf((char *)cmd,"disconfig 100");
	run_command(cmd, 0);
	mdelay(20);
	sprintf(cmd, "run emmcboot");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	return 0;
bootoldsys:

	if(!strcmp(curr_partition, "A"))
	{
		env_set("updata_from_part", "A");
		env_set("kernel_part", "kernel");
		env_set("fdt_part", "fdt");
		env_set("rootfs_part", "rootfs");
		env_set("emmcroot", "/dev/mmcblk0p10 ro");
		sprintf(cmd, "setenv fdtsize 0x%x",fdtsize);
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf(cmd, "setenv kernelsize 0x%x",kernelsize);
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
	}
	else if(!strcmp(curr_partition, "B"))
	{
		env_set("updata_from_part", "B");
		env_set("kernel_part", "kernel_b");
		env_set("fdt_part", "fdt_b");
		env_set("rootfs_part", "rootfs_b");
		env_set("emmcroot", "/dev/mmcblk0p14 ro");
		sprintf(cmd, "setenv fdtsize 0x%x",fdtsize);
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
		sprintf(cmd, "setenv kernelsize 0x%x",kernelsize);
		run_command(cmd, 0);
		printf("cmd=%s\n", cmd);
		mdelay(30);
	}
	env_set("update_from_ota", "no");
	mdelay(30);
	env_set("updata_status", "error");
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	mdelay(20);
	sprintf(cmd, "run emmcboot");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	return 1;
}
U_BOOT_CMD(
	update_from_emmc_ota, 4, 0, do_update_from_ota,
	"updata from emmc ota partiton",
	"<interface> <dev[:part]> <filename>\n"
);
#if 0
int do_boot_from_part(cmd_tbl_t * cmdtp, int flag, int argc, char *const argv[])
{
	char cmd[32];
	unsigned int index = 0;
	unsigned int ret = 0;
	char *load_from_kernel_part = NULL;
	load_from_kernel_part = env_get("load_from_part");
	if(!strcmp(load_from_kernel_part, "A"))
	{
		env_set("kernel_part", "kernel");
		env_set("emmcroot", "/dev/mmcblk1p10 rw");
	}
	else
	{
		env_set("kernel_part", "kernel_b");
		env_set("emmcroot", "/dev/mmcblk1p13 rw");
	}
	printf("load_from_kernel_part %s\n",load_from_kernel_part);
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	return 1;
}
U_BOOT_CMD(
	boot_from_part_set, 4, 0, do_boot_from_part,
	"updata from emmc ota partiton",
	"<interface> <dev[:part]> <filename>\n"
);
#endif
#endif