ark1668ed-bsp/u-boot/board/arkmicro/ark1668ed_devb_emmc/ark1668ed_devb_emmc.c

// SPDX-License-Identifier: GPL-2.0+
/*
 *
 */
#include <common.h>
#include <dwmmc.h>
#include <malloc.h>
#include <linux/delay.h>
#include <env.h>
#include <command.h>
#include <init.h>
#include <u-boot/crc.h>
#include <debug_uart.h>
#include <asm-generic/gpio.h>
#include <asm/arch/ark-common.h>
#include <../../../include/serial.h>

DECLARE_GLOBAL_DATA_PTR;

#define ARK1668ED_UPDATE_MAGIC	"ada7f0c6-7c86-11e9-8f9e-2a86e4085a59"

#define rSYS_BOOT_SAMPLE		(*(volatile unsigned int *)0x50000000)
#define rSYS_CPU_CTL            (*(volatile unsigned int *)0x50000034)

#define rSYS_DEVICE_CLK_CFG0	(*(volatile unsigned int *)0x50000060)
#define rSYS_DEVICE_CLK_CFG1	(*(volatile unsigned int *)0x50000064)
#define rSYS_SOFTRESET_CTL		(*(volatile unsigned int *)0x50000068)
#define rSYS_SOFTRESET_CTL1		(*(volatile unsigned int *)0x5000006c)

#define rMFC_MON_CFG            (*(volatile unsigned int *)0x500000E8)

#define rSYS_ANALOG_REG0		(*(volatile unsigned int *)0x50000100)

#define PAD_CTL0_TMP			(*(volatile unsigned int *)0x50000140)
#define PAD_CTL1_TMP			(*(volatile unsigned int *)0x50000144)
#define PAD_CTL2_TMP			(*(volatile unsigned int *)0x50000148)
#define PAD_CTL3_TMP			(*(volatile unsigned int *)0x5000014C)
#define PAD_CTL4_TMP			(*(volatile unsigned int *)0x50000150)
#define PAD_CTL5_TMP			(*(volatile unsigned int *)0x50000154)
#define PAD_CTL6_TMP			(*(volatile unsigned int *)0x50000158)
#define PAD_CTL7_TMP			(*(volatile unsigned int *)0x5000015C)
#define PAD_CTL8_TMP			(*(volatile unsigned int *)0x50000160)
#define PAD_CTL9_TMP			(*(volatile unsigned int *)0x50000164)
#define PAD_CTL10_TMP			(*(volatile unsigned int *)0x50000168)
#define PAD_CTL11_TMP			(*(volatile unsigned int *)0x5000016C)
#define PAD_CTL12_TMP			(*(volatile unsigned int *)0x50000170)
#define PAD_CTL13_TMP			(*(volatile unsigned int *)0x50000174)
#define PAD_CTL14_TMP			(*(volatile unsigned int *)0x50000178)
#define PAD_CTL15_TMP			(*(volatile unsigned int *)0x5000017c)
#define PAD_CTL16_TMP			(*(volatile unsigned int *)0x50000180)
#define PAD_CTL17_TMP			(*(volatile unsigned int *)0x50000184)
#define PAD_CTL18_TMP			(*(volatile unsigned int *)0x50000188)
#define PAD_CTL19_TMP			(*(volatile unsigned int *)0x5000018C)
#define PAD_CTL20_TMP			(*(volatile unsigned int *)0x50000190)

#define SDMMC_CLK_CFG			(*(volatile unsigned int *)0x50000050)

#define GPIOE_DR				(*(volatile unsigned int *)0x50900200)
#define GPIOE_DDR				(*(volatile unsigned int *)0x50900204)

static void dwmci_select_pad(void)
{
	unsigned int val;
	/* use sd/mmc 0 */
	val = PAD_CTL8_TMP;
	val &= ~(0x7 << 27);
	val |=  (0x1 << 27);
	PAD_CTL8_TMP = val;

	val = PAD_CTL9_TMP;
	val &= ~((0x7 << 24)|(0x7 << 21)|(0x7 << 18)|(0x7 << 15)|(0x7 << 12)|(0x7 << 9)|(0x7 << 6)|(0x7 << 3)|(0x7 << 0));
	val |=  ((0x1 << 24)|(0x1 << 21)|(0x1 << 18)|(0x1 << 15)|(0x1 << 12)|(0x1 << 9)|(0x1 << 6)|(0x1 << 3)|(0x1 << 0));
	PAD_CTL9_TMP = val;

}

int add_dwmci(struct dwmci_host *host, u32 max_clk, u32 min_clk);

#define ARK_MMC_CLK	24000000
static int ark_dwmci_init(char *name, u32 regbase, int bus_width, int index)
{
	struct dwmci_host *host = NULL;

	host = malloc(sizeof(struct dwmci_host));
	if (!host) {
		printf("dwmci_host malloc fail!\n");
		return 1;
	}
	memset(host, 0, sizeof(struct dwmci_host));
	host->name = name;
	host->ioaddr = (void *)regbase;
	host->buswidth = bus_width;
	host->dev_index = index;
	host->bus_hz = ARK_MMC_CLK;
	host->fifoth_val = 64;
	host->fifo_mode = 1;
	add_dwmci(host, host->bus_hz, 400000);

	return 0;
}

int board_mmc_init(struct bd_info *bis)
{
	ark_dwmci_init("ARK_MMC0", 0x40100000, 8, 0);
	return 0;
}

int dram_init(void)
{
	gd->ram_size = get_ram_size((void *)CFG_SYS_SDRAM_BASE,
				    CFG_SYS_SDRAM_SIZE);
	return 0;
}

int board_init(void)
{

	unsigned int val;
/* cpu1 disable */
	rSYS_CPU_CTL &= ~(1 << 1);

/*rMFC_MON_CFG*/
	val = rMFC_MON_CFG;
	val |= ((0x1<<1));
	rMFC_MON_CFG = val;

/*usb host softreset  */
	rSYS_SOFTRESET_CTL1 &= ~((1 << 22) | (1 << 5));
	rSYS_SOFTRESET_CTL &= ~(1 << 3);
	udelay(10);
	rSYS_SOFTRESET_CTL1 |= (1 << 22) | (1 << 5);
	rSYS_SOFTRESET_CTL |= (1 << 3);
	udelay(10);

/* set usb0 id */
	rSYS_ANALOG_REG0 &=  ~(0x1F<<16);
/* set usb1 id */
	rSYS_ANALOG_REG0 &=  ~(0x1F<<24);
/*usb1 5v gpio141 enable*/
	GPIOE_DDR |= (1<<(141 - 128));//Output Direction
	GPIOE_DR |= (1<<(141 - 128));//vale 1

	val =  PAD_CTL14_TMP;
	val &= ~((0x7 << 9));
	val |= (0x4 << 9);
	PAD_CTL14_TMP = val;
	dwmci_select_pad();
//emmc clk config clk:45000000
	SDMMC_CLK_CFG &= ~((0x1F << 0) | (0x1 << 6) | (0x1 << 7));
	SDMMC_CLK_CFG |=  (1 << 7) | (1 << 6) | 2;

	return 0;
}
//#ifndef CONFIG_DM_SERIAL
struct serial_device *default_serial_console(void)
{
	return &eserial1_device;
}
//#endif


#ifdef CONFIG_BOARD_EARLY_INIT_F
int board_early_init_f(void)
{
#ifdef CONFIG_DEBUG_UART
	debug_uart_init();
#endif
	return 0;
}
#endif

#if !defined(CONFIG_SPL_BUILD)
static int ark_update_emmc_partition(char *partition_name, 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));
	unsigned int *dstdata = (unsigned int *)(env_get_hex("cmploadaddr", 0));
#if ARK_UPDATE_SECURITY
	sprintf(cmd, "zipread usb 0 %s update.zip %s", env_get("loadaddr"), file_name);
#else
	sprintf(cmd, "fatload %s %s %s %s", env_get("update_dev_type"), env_get("update_dev_part"), env_get("loadaddr"), file_name);
#endif
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if (ret) {
		printf("Load %s from tf/usb error!!\n", file_name);
		return 1;
	}
#if (!ARK_UPDATE_SECURITY)
	file_size = env_get_ulong("filesize", 16, 0x2000);
	crc_src = crc32(0, (const unsigned char *)srcdata, file_size);
	printf(">>>>>%s crc_src 0x%x!!\n", file_name, crc_src);
	ret = ark_check_data_from_devide(file_name, crc_src);
	if (ret) {
		printf("check data %s from tf/usb crc error!!\n", file_name);
		return 1;
	}
#endif
	//burn data to emmc
	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_src = crc32(0, (const unsigned char *)dstdata, file_size);
	ret  = ark_check_data_from_partition(partition_name, crc_src);
	if (ret)
		return 1;
#if ARK_BOOT_SECURITY
	if (!strcmp(partition_name, "kernel"))
		env_set_hex("crc_kernel_a", crc_src);
	else if (!strcmp(partition_name, "kernel_b"))
		env_set_hex("crc_kernel_b", crc_src);
#endif
	return 0;
}

#if (!ARK_UPDATE_SECURITY)
static int ark_update_emmc_rootfs_from_media(char *partition_name)
{
	char cmd[32];
	int ret = 0;
	char *update_device = env_get("update_dev_type");

	printf("\r\n****** update %s from %s:rootfs.ext2 .....\r\n", partition_name, update_device);
	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) {
		printf("Error:rootfs file maybe not in device!!!\n");
		return 2;
	}
	sprintf(cmd, "updaterootfs %s", partition_name);
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	return ret;
}

static int ark_do_update_from_media(unsigned int updateDevice)
{
	char cmd[32];
	unsigned int ret = 0;
	char *update_dev = NULL;
	static char curr_partition[32];
	unsigned char update_fdt_name[32];
	unsigned char flag_partiton = 0;//0--A partiton,1---B partition
	unsigned int dis_pos_x = 0;
	unsigned int dis_pos_y = 0;
	unsigned int resetuboot = 0;
	unsigned int fdtsize = 0;
	unsigned int kernelsize = 0;
#if	ARK_BOOT_SECURITY
	unsigned int kernelcrc = 0;
#endif

	sprintf(cmd, "mmc dev %s", env_get("emmc_dev_part"));
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	sprintf((char *)cmd, "disconfig 0");
	run_command(cmd, 0);
	resetuboot = env_get_hex("ubootreset", 0);
//	curr_partition  = env_get("updata_from_part");
	sprintf(curr_partition, "%s", env_get("updata_from_part"));
	fdtsize = env_get_hex("fdtsize", 0);
	kernelsize = env_get_hex("kernelsize", 0);
#if	ARK_BOOT_SECURITY
	kernelcrc = env_get_hex("crc_kernel", 0);
#endif
	mdelay(20);
	printf(">>>>>>fdtsize = 0x%x,kernelsize = 0x%x,curr_partition %s\n", fdtsize, kernelsize, curr_partition);
	run_command("env default -f -a", 0);
	mdelay(500);
	if (updateDevice) {
		printf("update form mmc...\n");
		env_set("update_dev_type", "mmc");
		env_set("update_dev_part", env_get("sd_dev_part"));
	} else {
		printf("update form usb...\n");
		env_set("update_dev_type", "usb");
		env_set("update_dev_part", "0");
		env_set("updata_status", "usb");
	}
	udelay(20);
//	update_fdt = env_get("boardfdt");
//	sprintf(update_fdt_name, "%s", env_get("boardfdt"));
	get_crc_data_from_device("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");
			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);
#if	ARK_BOOT_SECURITY
			sprintf(cmd, "setenv crc_kernel 0x%x", kernelcrc);
			printf(">>>>>>>cmd=%s\n", cmd);
			run_command(cmd, 0);
			mdelay(10);
#endif
			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;
	}
	sprintf(update_fdt_name, "%s", env_get("boardfdt"));
	update_dev = env_get("update_dev_type");
	printf(">>>>>>>>>>update_dev %s\n", update_dev);
	if (!strcmp(update_dev, "mmc")) {
		env_set("updata_status", "none");
		env_set("updata_from_part", "A");
		flag_partiton = 0;
	} else if (!strcmp(update_dev, "usb")) {
		env_set("updata_status", "usb");
		if (!strcmp(curr_partition, "A"))
			flag_partiton = 1;
		else if (!strcmp(curr_partition, "B"))
			flag_partiton = 0;
	}
	printf(">>>>>>curr_partition %s,update_fdt:%s,resetuboot %d.....\n", curr_partition, update_fdt_name, resetuboot);
/****** 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;
	}

/****** 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;
	}
#if 0
/****** 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");
	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_media("rootfs");
	else
		ret = ark_update_emmc_rootfs_from_media("rootfs_b");
	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;
	}
	printf("\r\n **** set the env to partition .....\r\n");
	//mmc update set part A
	if (!strcmp(update_dev, "mmc")) {
		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);
#if	ARK_BOOT_SECURITY
			sprintf(cmd, "setenv crc_kernel 0x%x", crc_kernel_a);
			printf(">>>>>>>cmd=%s\n", cmd);
			run_command(cmd, 0);
			mdelay(10);
#endif
	} else if (!strcmp(update_dev, "usb")) {
		printf(">>>>>>>>>curr_partition %s\n", curr_partition);
		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);
#if	ARK_BOOT_SECURITY
			sprintf(cmd, "setenv crc_kernel 0x%x", crc_kernel_b);
			printf(">>>>>>>cmd=%s\n", cmd);
			run_command(cmd, 0);
			mdelay(10);
#endif
		} 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);
#if	ARK_BOOT_SECURITY
			sprintf(cmd, "setenv crc_kernel 0x%x", crc_kernel_a);
			printf(">>>>>>>cmd=%s\n", cmd);
			run_command(cmd, 0);
			mdelay(10);
#endif
		}
	}
	mdelay(5);
	env_set("need_update", "no");
	mdelay(5);
	env_set("updata_status", "none");
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	mdelay(30);
	sprintf((char *)cmd, "disconfig 100");
	run_command(cmd, 0);
	printf("\r\n **** update the device ok! .....\r\n");
	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);
#if	ARK_BOOT_SECURITY
		sprintf(cmd, "setenv crc_kernel 0x%x", kernelcrc);
		printf(">>>>>>>cmd=%s\n", cmd);
		run_command(cmd, 0);
		mdelay(10);
#endif
	} 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);
#if	ARK_BOOT_SECURITY
		sprintf(cmd, "setenv crc_kernel 0x%x", kernelcrc);
		printf(">>>>>>>cmd=%s\n", cmd);
		run_command(cmd, 0);
		mdelay(10);
#endif
	}
	env_set("updata_status", "error");
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	mdelay(20);
	sprintf((char *)cmd, "disconfig 100");
	run_command(cmd, 0);

	return 1;
}
#else
/*
 *ark1668Ed secured upgrade RSA2048 PSS mode
 */
#include "keyts.h"
#include <../lib/rsa_ark/rsa.h>

static int ark_update_emmc_rootfs_from_media(char *partition_name)
{
	char cmd[32];
	int ret = 0;
	char *file_name = "update/rootfs.ext2";

	printf("\r\n****** update %s from %s:rootfs.ext2 .....\r\n", partition_name, env_get("update_dev_type"));
	ret = ark_burn_rootfs_data_to_media(partition_name, file_name);
	if (ret != 0)
		return -1;
	return ret;
}

static int ark_secured_update_from_media(unsigned int updateDevice)
{
	char cmd[32];
	unsigned int ret = 0;
	char *update_dev = NULL;
	static char curr_partition[32];
	unsigned char update_fdt_name[32];
	unsigned char flag_partiton = 0;//0--A partiton,1---B partition
	unsigned int dis_pos_x = 0;
	unsigned int dis_pos_y = 0;
	unsigned int resetuboot = 0;
	unsigned int fdtsize = 0;
	unsigned int kernelsize = 0;
	rsa_pk_t pk = {0};

	sprintf(cmd, "mmc dev %s", env_get("emmc_dev_part"));
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	sprintf((char *)cmd, "disconfig 0");
	run_command(cmd, 0);
	resetuboot = env_get_hex("ubootreset", 0);
	sprintf(curr_partition, "%s", env_get("updata_from_part"));
	fdtsize = env_get_hex("fdtsize", 0);
	kernelsize = env_get_hex("kernelsize", 0);
	mdelay(20);
	printf(">>>>>>fdtsize = 0x%x,kernelsize = 0x%x,curr_partition %s\n", fdtsize, kernelsize, curr_partition);
	run_command("env default -f -a", 0);
	mdelay(500);
	if (updateDevice) {
		printf("update form mmc...\n");
		env_set("update_dev_type", "mmc");
		env_set("update_dev_part", env_get("sd_dev_part"));
	} else {
		printf("update form usb...\n");
		env_set("update_dev_type", "usb");
		env_set("update_dev_part", "0");
		env_set("updata_status", "usb");
	}
	udelay(20);
	get_crc_data_from_device("update/crcdata.bin");
	dis_pos_x = 6;
	dis_pos_y = 20;
	pk.bits = KEY_M_BITS;
	memcpy(&pk.modulus[RSA_MAX_MODULUS_LEN-sizeof(key_pm)],  key_pm,  sizeof(key_pm));
	memcpy(&pk.exponent[RSA_MAX_MODULUS_LEN-sizeof(key_pe)],  key_pe,  sizeof(key_pe));
	ret = ark_PssVerify_signature("update/ubootspl.bin", "update/META-INF/ubootspl.SF", "update/META-INF/ubootspl.RSA", pk);
	if (ret == 0) {
		ret = ark_update_emmc_partition("bootstrap", "update/ubootspl.bin");
		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;
		}
	} 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;
	}
	ret = ark_PssVerify_signature("update/u-boot.img", "update/META-INF/u-boot.SF", "update/META-INF/u-boot.RSA", pk);
	if (ret == 0) {
		ret = ark_update_emmc_partition("bootloader", "update/u-boot.img");
		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");
				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;
		}
	} 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;
	}
	sprintf(update_fdt_name, "%s", env_get("boardfdt"));
	update_dev = env_get("update_dev_type");
	printf(">>>>>>>>>>update_dev %s\n", update_dev);
	if (!strcmp(update_dev, "mmc")) {
		env_set("updata_status", "none");
		env_set("updata_from_part", "A");
		flag_partiton = 0;
	} else if (!strcmp(update_dev, "usb")) {
		env_set("updata_status", "usb");
		if (!strcmp(curr_partition, "A"))
			flag_partiton = 1;
		else if (!strcmp(curr_partition, "B"))
			flag_partiton = 0;
	}
	printf(">>>>>>curr_partition %s,update_fdt:%s,resetuboot %d.....\n", curr_partition, update_fdt_name, resetuboot);
	ret = ark_PssVerify_signature("update/ark1668ed_devb_emmc.dtb", "update/META-INF/ark1668ed_devb_emmc.SF", "update/META-INF/ark1668ed_devb_emmc.RSA", pk);
	if (ret == 0) {
		if (flag_partiton == 0)
			ret = ark_update_emmc_partition("fdt", "update/ark1668ed_devb_emmc.dtb");
		else
			ret = ark_update_emmc_partition("fdt_b", "update/ark1668ed_devb_emmc.dtb");
		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;
		}
	} 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;
	}
	ret = ark_PssVerify_signature("update/zImage", "update/META-INF/zImage.SF", "update/META-INF/zImage.RSA", pk);
	if (ret == 0) {
		if (flag_partiton == 0)
			ret = ark_update_emmc_partition("kernel", "update/zImage");
		else
			ret = ark_update_emmc_partition("kernel_b", "update/zImage");
		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;
		}
	} 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", "update/u-boot.img");
	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 ******/
	ret = ark_PssVerify_signature("update/rootfs.ext2", "update/META-INF/rootfs.SF", "update/META-INF/rootfs.RSA", pk);
	if (ret == 0) {
		if (flag_partiton == 0)
			ret = ark_update_emmc_rootfs_from_media("rootfs");
		else
			ret = ark_update_emmc_rootfs_from_media("rootfs_b");
		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;
		}
	} 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, "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;
	}
	printf("\r\n **** set the env to partition .....\r\n");
	//mmc update set part A
	if (!strcmp(update_dev, "mmc")) {
		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);
	} else if (!strcmp(update_dev, "usb")) {
		printf(">>>>>>>>>curr_partition %s\n", curr_partition);
		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);
#if ARK_BOOT_SECURITY
			sprintf(cmd, "setenv crc_kernel %s", env_get("crc_kernel_b"));
			run_command(cmd, 0);
			printf("cmd=%s\n", cmd);
#endif
		} 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);
#if ARK_BOOT_SECURITY
			sprintf(cmd, "setenv crc_kernel %s", env_get("crc_kernel_a"));
			run_command(cmd, 0);
			printf("cmd=%s\n", cmd);
#endif
		}
	}
	mdelay(5);
	env_set("need_update", "no");
	mdelay(5);
	env_set("updata_status", "none");
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	mdelay(30);
	sprintf((char *)cmd, "disconfig 100");
	run_command(cmd, 0);
	printf("\r\n **** update the device ok! .....\r\n");
	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("updata_status", "error");
	sprintf(cmd, "saveenv");
	printf("cmd=%s\n", cmd);
	run_command(cmd, 0);
	mdelay(20);
	sprintf((char *)cmd, "disconfig 100");
	run_command(cmd, 0);

	return 1;
}
#endif

#if ARK_BOOT_SECURITY
static int ark_check_kernel_from_emmc(void)
{
	int ret = -1;
	unsigned int file_size, crc_src, crc_kernel;
	char cmd[128] = { 0 };

	sprintf(cmd, "emmc read %s %s %s", env_get("loadaddr"), env_get("kernel_part"), env_get("kernelsize"));
	printf("cmd=%s\n", cmd);
	ret = run_command(cmd, 0);
	if (ret) {
		printf("emmc write data error!!!\n");
		return 1;
	}
	crc_src = crc32(0, (const unsigned char *)dstdata, env_get_hex("kernelsize", 0));
	crc_kernel = env_get_hex("crc_kernel", 0)
	printf("crc_src = 0x%x,crc_kernel = 0x%x\n", crc_src, crc_kernel);
	if (crc_src != crc_kernel)
		return 1;
	if (ret)
		return 1;
	return 0;
}
#endif

int board_late_init(void)
{
	char cmd[128];
	char *update_ota = NULL, *need_update = NULL;
	unsigned int loadaddr;
	int do_update = 0, update_from_mmc = 1;
	int update_detect = 0;//0:no update 1:need_update env 2:usb update boot 3:sd update boot


	update_ota = env_get("update_from_ota");
	need_update = env_get("need_update");
	if (!strcmp(need_update, "yes"))
		update_detect = 1;
	else if ((rSYS_BOOT_SAMPLE & 7) == 5)
		update_detect = 2;
	else if ((rSYS_BOOT_SAMPLE & 7) == 4)
		update_detect = 3;
//由于usb升级检测的时候，会需要一段时间所以这个地方需要时间长一些,设置6s
	ark_watchdog_start(6000);
	printf("update_detect=%d.\n", update_detect);
	if (update_detect) {
		loadaddr = env_get_hex("loadaddr", 0);
		if (loadaddr)
			memset((void *)loadaddr, 0, strlen(ARK1668ED_UPDATE_MAGIC));
		if (update_detect == 1 || update_detect == 3) {
#if ARK_UPDATE_SECURITY
			sprintf(cmd, "zipread mmc %s %s update.zip update/update-magic", env_get("sd_dev_part"), env_get("loadaddr"));
#else
			sprintf(cmd, "fatload %s %s %s update-magic", "mmc", env_get("update_dev_part"), env_get("loadaddr"));
#endif
			run_command(cmd, 0);
			if (loadaddr && !memcmp((void *)loadaddr, ARK1668ED_UPDATE_MAGIC, strlen(ARK1668ED_UPDATE_MAGIC))) {
				do_update = 1;
				goto update_done;
			} else {
				printf("Wrong update magic, do not update from mmc.\n");
			}
		}

		if (update_detect == 1 || update_detect == 2) {
			run_command("usb start", 0);
#if ARK_UPDATE_SECURITY
			sprintf(cmd, "zipread usb 0 %s update.zip update/update-magic", env_get("loadaddr"));
#else
			sprintf(cmd, "fatload %s %s %s update-magic", "usb", "0", env_get("loadaddr"));
#endif
			run_command(cmd, 0);
			if (loadaddr && !memcmp((void *)loadaddr, ARK1668ED_UPDATE_MAGIC, strlen(ARK1668ED_UPDATE_MAGIC))) {
				do_update = 1;
				update_from_mmc = 0;
					goto update_done;
			} else {
				printf("Wrong update magic, do not update from usb.\n");
			}
		}
	}
	if (!strcmp(update_ota, "yes")) {
		do_update = 0;
//升级的时候关闭看门够功能
		ark_watchdog_stop();
		sprintf(cmd, "update_from_emmc_ota");
		printf("cmd=%s\n", cmd);
		run_command(cmd, 0);
	}
update_done:
	if (do_update) {
//升级的时候关闭看门够功能
		ark_watchdog_stop();
		run_command("emmc erase.part userdata", 0);
		env_set("need_update", "no");
		env_set("do_update", "yes");
#if ARK_UPDATE_SECURITY
		ark_secured_update_from_media(update_from_mmc);
#else
		ark_do_update_from_media(update_from_mmc);
#endif
	} else {
		env_set("do_update", "no");
	}
	return 0;
}

#endif