/* SPDX-License-Identifier: GPL-2.0+
 * (C) Copyright 2018-2020
 * Allwinner Technology Co., Ltd. <www.allwinnertech.com>
 * wangwei <wangwei@allwinnertech.com>
 *
 * Some init for sunxi platform.
 */

#include <common.h>
#include <asm/io.h>
#include <sunxi_board.h>
#include <sunxi_flash.h>
#include <fdt_support.h>
#include <blk.h>
#include <part.h>
#include <asm/arch/rtc.h>
#include <asm/arch/dram.h>
#include <private_uboot.h>
#include <asm/arch/efuse.h>
#include <sunxi_nand.h>
#include <android_misc.h>
#include <sys_partition.h>
#include <sys_config.h>
#include <sunxi-ir.h>
#include <smc.h>
#include <mmc.h>

DECLARE_GLOBAL_DATA_PTR;

/*define ir or key mode value*/
#define EFEX_VALUE                                      (0x81)
#define SPRITE_RECOVERY_VALUE                           (0X82)
#define BOOT_RECOVERY_VALUE                             (0x83)
#define BOOT_FACTORY_VALUE                              (0x84)


#define PARTITION_SETS_MAX_SIZE 1024
#define PARTITION_NAME_MAX_SIZE 16
#define ROOT_PART_NAME_MAX_SIZE (PARTITION_NAME_MAX_SIZE + 5)
#define DEV_PART_NAME_MAX_SIZE (PARTITION_NAME_MAX_SIZE + sizeof("/dev/"))

#ifdef CONFIG_DRAM_VER_1
int update_fdt_dram_para(void *dtb_base)
{
	/*fix dram para*/
	int nodeoffset = 0;
	uint32_t *dram_para = NULL;
	dram_para = (uint32_t *)uboot_spare_head.boot_data.dram_para;

	pr_msg("(weak)update dtb dram start\n");
	nodeoffset = fdt_path_offset(dtb_base, "/dram");
	if (nodeoffset < 0) {
		pr_err("## error: %s : %s\n", __func__, fdt_strerror(nodeoffset));
		return -1;
	}
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_clk", dram_para[0]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_type", dram_para[1]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_zq", dram_para[2]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_odt_en", dram_para[3]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_para1", dram_para[4]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_para2", dram_para[5]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_mr0", dram_para[6]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_mr1", dram_para[7]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_mr2", dram_para[8]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_mr3", dram_para[9]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr0", dram_para[10]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr1", dram_para[11]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr2", dram_para[12]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr3", dram_para[13]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr4", dram_para[14]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr5", dram_para[15]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr6", dram_para[16]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr7", dram_para[17]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr8", dram_para[18]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr9", dram_para[19]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr10", dram_para[20]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr11", dram_para[21]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr12", dram_para[22]);
	fdt_setprop_u32(dtb_base, nodeoffset, "dram_tpr13", dram_para[23]);
	gd->bd->bi_dram[0].size = (phys_size_t)uboot_spare_head.boot_data.dram_scan_size * 1024 * 1024;
	pr_msg("update dtb dram  end\n");
	return 0;
}
#else
#error "platform not support"
#endif

static int fdt_enable_node(char *name, int onoff)
{
	int nodeoffset = 0;
	int ret = 0;

	nodeoffset = fdt_path_offset(working_fdt, name);
	ret = fdt_set_node_status(working_fdt, nodeoffset,
		onoff ? FDT_STATUS_OKAY: FDT_STATUS_DISABLED, 0);

	if (ret < 0) {
		printf("disable nand error: %s\n", fdt_strerror(ret));
	}
	return ret;
}

void sunxi_dump(void *addr, unsigned int size)
{
#if 1
	print_buffer((ulong)addr, addr, 4, ALIGN(size, 16)/4, 4);
#else
	int i, j;
	char *buf = (char *)addr;

	for (j = 0; j < size; j += 16) {
		for (i = 0; (i < 16 && i < size); i++) {
			printf("%02x ", buf[j + i] & 0xff);
		}
		printf("\n");
	}
	printf("\n");
#endif
	return;

}

/*
* name    :  sunxi_str_replace
* fucntion:  replace a word in string  which separated by a space
* note      :  sunxi_str_replace("abc def gh", "def", "replace")    get    "abc replace gh"
*/
static int sunxi_str_replace(char *dest_buf, char *goal, char *replace)
{
	char tmp[128];
	char tmp_str[16];
	int  goal_len, rep_len, dest_len;
	int  i, j, k;

	if( (goal == NULL) || (dest_buf == NULL))
		return -1;

	memset(tmp, 0, 128);
	strcpy(tmp, dest_buf);

	goal_len = strlen(goal);
	dest_len = strlen(dest_buf);

	if(replace != NULL)
		rep_len = strlen(replace);
	else
		rep_len = 0;

	j = 0;
	for(i=0;tmp[i];) {
		k = 0;
		while(((tmp[i] != ' ') && (tmp[i] != 0) )|| (tmp[i+1] == ' '))
		{
			tmp_str[k++] = tmp[i];
			i ++;
			if(i >= dest_len)
				break;
		}
		i ++;
		tmp_str[k] = 0;
		if(!strcmp(tmp_str, goal))
		{
			if(rep_len)
			{
				strcpy(dest_buf + j, replace);
				if(tmp[j + goal_len])
				{
					memcpy(dest_buf + j + rep_len, tmp + j + goal_len, dest_len - j - goal_len);
					dest_buf[dest_len - goal_len + rep_len] = 0;
				}
			}
			else
			{
				if(tmp[j + goal_len])
				{
					memcpy(dest_buf + j, tmp + j + goal_len, dest_len - j - goal_len);
					dest_buf[dest_len - goal_len + rep_len] = 0;
				}
			}

			return 0;
		}
		j = i;
	}

	return 0;
}

static int write_recovery_msg_to_misc(char *recovery_msg)
{
	u32 misc_offset = 0;
	char misc_args[2048];
	static struct bootloader_message *misc_message;
	int ret;

	memset(misc_args, 0x0, 2048);
	misc_message = (struct bootloader_message *)misc_args;

	misc_offset = sunxi_partition_get_offset_byname("misc");
	if (!misc_offset) {
		printf("no misc partition\n");
		return 0;
	}
	ret = sunxi_flash_read(misc_offset, 2048 / 512, misc_args);
	if (!ret) {
		printf("error: read misc partition\n");
		return 0;
	}

	if (!strcmp("ir-or-key-recovery", (const char *)recovery_msg)) {
		strcpy(misc_message->command, "boot-recovery");
	} else if (!strcmp("ir-factory", (const char *)recovery_msg)) {
		strcpy(misc_message->command, "boot-recovery");
		strcpy(misc_message->recovery,
		       "recovery\n--wipe_data\n--locale=zh_CN\n");
	} else if (!strcmp("ir-efex", (const char *)recovery_msg)) {
		strcpy(misc_message->command, "efex");
	} else if (!strcmp("sysrecovery", (const char *)recovery_msg)) {
		strcpy(misc_message->command, "sysrecovery");
		/*    strcpy(misc_message->recovery, "sysrecovery"); */
	} else if (!strcmp("erase_misc", (const char *)recovery_msg)) {
		memset(misc_args, 0x0, 2048);
	}
	sunxi_flash_write(misc_offset, 2048 / 512, misc_args);
	return 0;
}

#ifdef CONFIG_RECOVERY_KEY

#define RECOVERY_KEY_EFEX_MODE				(0x0)
#define RECOVERY_KEY_ONEKEY_SPRITE_RECOVERY_MODE	(0x1)
#define RECOVERY_KEY_RECOVERY_MODE			(0x2)
#define RECOVERY_KEY_FACTORY_MODE			(0x3)

#define RECOVERY_KEY_EFEX_VALUE				(0x81)
#define RECOVERY_KEY_SPRITE_RECOVERY_VALUE		(0X82)
#define RECOVERY_KEY_BOOT_RECOVERY_VALUE		(0x83)
#define RECOVERY_KEY_BOOT_FACTORY_VALUE			(0x84)

#define KEY_PRESS_MODE_DISABLE	(0X0)
#define KEY_PRESS_MODE_ENABLE	(0x1)
#define KEY_BOOT_RECOVERY		"/soc/key_boot_recovery"

#ifdef RECOVERY_KEY_DEBUG
#define key_info(fmt...) tick_printf(fmt)
#else
#define key_info(fmt...)
#endif

int check_recovery_key(void)
{
	user_gpio_set_t	gpio_recovery;
	__u32 gpio_hd;
	int ret;
	int gpio_value = 0;
	int used = 0;
	int mode = 0;
	int press_mode = 0;
	int press_time = 0;

	if (get_boot_work_mode() == WORK_MODE_BOOT) {
		/*check physical gpio pin*/
		ret = script_parser_fetch(KEY_BOOT_RECOVERY, "recovery_key_used",
				(int *)&used, sizeof(int) / 4);
		if (ret || !used) {
			key_info("[key recovery] no use\n");
			return 0;
		}
		ret = fdt_get_one_gpio(KEY_BOOT_RECOVERY, "recovery_key", &gpio_recovery);
		if (ret) {
			key_info("[key recovery] can't find recovery_key config.\n");
			return 0;
		}
		gpio_recovery.mul_sel = 0;		/*forced to input*/
		gpio_hd = sunxi_gpio_request(&gpio_recovery, 1);
		if (!gpio_hd) {
			pr_error("[key recovery] gpio request fail!\n");
			return 0;
			/*gpio request fail,just return.*/
		}

		int time;
		gpio_value = 0;
		for (time = 0; time < 5; time++) {
			gpio_value += gpio_read_one_pin_value(gpio_hd, 0);
			mdelay(1);
		}

		if (gpio_value) {
			key_info("[key recovery] no key press.\n");
			return 0;
			/*no recovery key was pressed, just return.*/
		}

		key_info("[key recovery] find the key\n");
		script_parser_fetch(KEY_BOOT_RECOVERY, "press_mode_enable",
			(int *)&press_mode, sizeof(int) / 4);
		if (press_mode == KEY_PRESS_MODE_DISABLE) {
			script_parser_fetch(KEY_BOOT_RECOVERY, "key_work_mode",
				(int *)&mode, sizeof(int) / 4);
			key_info("[key recovery] do not use prese mode, \
					key_work_mode = %d\n", mode);
		} else if (press_mode == KEY_PRESS_MODE_ENABLE) {
			script_parser_fetch(KEY_BOOT_RECOVERY, "key_press_time",
				(int *)&press_time, sizeof(int) / 4);
			key_info("[key recovery] use prese mode, \
				and key_press_time = %d ms\n", press_time);
			gpio_value = 0;
			for (time = press_time; time > 0; time -= 100) {
				mdelay(100); /*detect key value per 100ms*/
				gpio_value += gpio_read_one_pin_value(gpio_hd, 0);

				/*key was loosed during press time,will not detect key value any more*/
				if (gpio_value)
					break;
			}
			/*key was lossed during press time, so use short_press_mode*/
			if (gpio_value) {
				script_parser_fetch(KEY_BOOT_RECOVERY, "short_press_mode",
					(int *)&mode, sizeof(int) / 4);
				key_info("[key recovery] key short press, short_press_mode = %d\n", mode);
			} else {
			/*key was always pressed in key_press_time, so use long_press_mode*/
				script_parser_fetch(KEY_BOOT_RECOVERY, "long_press_mode",
					(int *)&mode, sizeof(int) / 4);
				key_info("[key recovery] key long press, long_press_mode = %d\n", mode);
			}
		}

		switch (mode) {
		case RECOVERY_KEY_EFEX_MODE:
			gd->key_pressd_value = RECOVERY_KEY_EFEX_VALUE;
			break;
		case RECOVERY_KEY_ONEKEY_SPRITE_RECOVERY_MODE:
			gd->key_pressd_value = RECOVERY_KEY_SPRITE_RECOVERY_VALUE;
			break;
		case RECOVERY_KEY_RECOVERY_MODE:
			gd->key_pressd_value = RECOVERY_KEY_BOOT_RECOVERY_VALUE;
			break;
		case RECOVERY_KEY_FACTORY_MODE:
			gd->key_pressd_value = RECOVERY_KEY_BOOT_FACTORY_VALUE;
			break;
		default:
			gd->key_pressd_value = RECOVERY_KEY_BOOT_RECOVERY_VALUE;
			break;
		}

	}

	return 0;
}
#endif

void sunxi_respond_ir_key_action(void)
{
	int key_value;
#ifdef CONFIG_IR_BOOT_RECOVERY
	int ir_time_out = get_timer_masked();
	while (get_timer_masked() - ir_time_out < 200) {
		if (gd->ir_detect_status != IR_DETECT_NULL)
			break;
	}
	ir_disable();
#endif
	key_value = gd->key_pressd_value;
	/* //ir factory or key factory */
	if (key_value == 0) {
		return;
	} else if (key_value == BOOT_FACTORY_VALUE) {
		printf("[boot factory] set misc : boot factory and wipe data\n");
		write_recovery_msg_to_misc("ir-factory");
	} else if (key_value == EFEX_VALUE) {
		/* //ir efex or key efex */
		printf("[boot efex] set misc : boot efex\n");
		write_recovery_msg_to_misc("ir-efex");
	} else if (key_value == SPRITE_RECOVERY_VALUE) {
		/* //ir sprite recovery */
		printf("[ir sysrecovery] set misc : boot recovery and sysrecovery \n");
		write_recovery_msg_to_misc("sysrecovery");
	} else if (key_value == BOOT_RECOVERY_VALUE) {
		/* //ir recovery or key recovery */
		printf("[boot recovery] set misc : boot recovery\n");
		write_recovery_msg_to_misc("ir-or-key-recovery");
	}
}

static int sunxi_get_bootcmd_from_rtc(void)
{
	u8 bootmode_flag = 0;

	bootmode_flag = rtc_get_bootmode_flag();
	/*clear rtc*/
	rtc_set_bootmode_flag(0);
	switch (bootmode_flag) {
	case SUNXI_EFEX_CMD_FLAG:
		return SUNXI_EFEX_CMD_FLAG;
	case SUNXI_BOOT_RECOVERY_FLAG:
		return SUNXI_BOOT_RECOVERY_FLAG;
	case SUNXI_FASTBOOT_FLAG:
		return SUNXI_FASTBOOT_FLAG;
	case SUNXI_UBOOT_FLAG:
		return SUNXI_UBOOT_FLAG;
	default:
		return 0;
		break;
	}
}

static int sunxi_get_bootcmd_from_adckey(void)
{
	typedef struct adc_key_info {
		char *key_type;
		u32 key_flag;
	} _adc_key_info;
	int key_high, key_low;
	int keyvalue, i;
	char key_mode[16] = {0};
	_adc_key_info key_info_table[] = {
		{"recovery", SUNXI_BOOT_RECOVERY_FLAG},
		{"fastboot", SUNXI_FASTBOOT_FLAG},
		{"fel", SUNXI_EFEX_CMD_FLAG},
	};

	keyvalue = uboot_spare_head.boot_data.key_input;
	pr_msg("key %d\n", keyvalue);
	if (keyvalue) {
		for (i = 0; i < sizeof(key_info_table)/sizeof(key_info_table[0]); i++) {
			sprintf(key_mode, "/soc/%s_key", key_info_table[i].key_type);
			script_parser_fetch(key_mode, "key_max", &key_high, 0);
			script_parser_fetch(key_mode, "key_min", &key_low, 0);
			if (key_high || key_low) {
				pr_notice("%s key high %d, low %d\n", key_info_table[i].key_type, key_high, key_low);
				if ((keyvalue >= key_low) && (keyvalue <= key_high)) {
					pr_notice("key found, android %s\n", key_info_table[i].key_type);
					return key_info_table[i].key_flag;
				}
			}
		}
	}
	return 0;
}

static int sunxi_get_bootcmd_from_misc(void)
{
	u32 misc_offset = 0;
	char misc_args[2048];
	char misc_fill[2048];
	struct bootloader_message *misc_message;
	int misc_mode;

	misc_message = (struct bootloader_message *)misc_args;
	memset(misc_args, 0x0, 2048);
	memset(misc_fill, 0xff, 2048);

	misc_offset = sunxi_partition_get_offset_byname("misc");
	if (!misc_offset) {
		pr_msg("no misc partition is found\n");
		return 0;
	} else {
		pr_msg("misc partition found\n");
		sunxi_flash_read(misc_offset, 2048 / 512, misc_args);
	}

	if (strstr((const char *)misc_message->command, "efex")) {
		misc_mode = SUNXI_EFEX_CMD_FLAG;
		/*"sysrecovery" must judge before "recovery" !!!*/
	} else if (strstr((const char *)misc_message->command, "sysrecovery")) {
		misc_mode = SUNXI_SYS_RECOVERY_FLAG;
	} else if (strstr((const char *)misc_message->command, "recovery")) {
		misc_mode = SUNXI_BOOT_RECOVERY_FLAG;
	} else if (strstr((const char *)misc_message->command, "bootloader")) {
		misc_mode = SUNXI_FASTBOOT_FLAG;
	} else if (strstr((const char *)misc_message->command, "uboot")) {
		misc_mode = SUNXI_UBOOT_FLAG;
	} else {
		misc_mode = 0;
	}
	if ((misc_mode) || *(misc_message->recovery))
		print_buffer((ulong)misc_args, misc_args, 4, 0x50, 4);

	if (strstr((const char *)misc_message->recovery, "update_package") ==
	    NULL) {
		memset(misc_message->command, 0x0,
		       sizeof(misc_message->command));
		sunxi_flash_write(misc_offset, 2048 / 512, misc_args);
	}
	return misc_mode;
}

int sunxi_set_bootcmd(char *bootcmd)
{
	int i, bootmode[4] = {0};
	bootmode[1] = sunxi_get_bootcmd_from_adckey();
	bootmode[2] = sunxi_get_bootcmd_from_rtc();
	bootmode[3] = sunxi_get_bootcmd_from_misc();
	for (i = 1; i < sizeof(bootmode)/sizeof(bootmode[0]); i++) {
		if (bootmode[i]) {
			bootmode[0] = bootmode[i];
			tick_printf("bootmode[%d]:0x%x\n", i, bootmode[i]);
			break;
		}
	}
	switch (bootmode[0]) {
	case SUNXI_EFEX_CMD_FLAG:
		sunxi_board_run_fel();
		break;
	case SUNXI_SYS_RECOVERY_FLAG:
		set_boot_work_mode(WORK_MODE_SPRITE_RECOVERY);
		env_set("sysrecovery", "sprite_test");
		strncpy(bootcmd, "run sysrecovery",
			sizeof("run sysrecovery"));
	case SUNXI_BOOT_RECOVERY_FLAG:
		sunxi_str_replace(bootcmd, "boot_normal", "boot_recovery");
		break;
	case SUNXI_FASTBOOT_FLAG:
		sunxi_str_replace(bootcmd, "boot_normal", "boot_fastboot");
		break;
	case SUNXI_UBOOT_FLAG:
		sunxi_set_uboot_shell(1);
		break;
	default:
		break;
	}

	return 0;
}

int sunxi_update_bootcmd(void)
{
	char  boot_commond[128];
	int   storage_type = get_boot_storage_type();

	memset(boot_commond, 0x0, 128);
	strncpy(boot_commond, env_get("bootcmd"), sizeof(boot_commond)-1);
	debug("base bootcmd=%s\n", boot_commond);

	if ((storage_type == STORAGE_SD) || (storage_type == STORAGE_EMMC) ||
	    storage_type == STORAGE_EMMC3) {
		sunxi_str_replace(boot_commond, "setargs_nand", "setargs_mmc");
		debug("bootcmd set setargs_mmc\n");
	} else if (storage_type == STORAGE_NOR) {
		sunxi_str_replace(boot_commond, "setargs_nand", "setargs_nor");
	} else if (storage_type == STORAGE_NAND) {
		debug("bootcmd set setargs_nand\n");
	}

	sunxi_set_bootcmd(boot_commond);

	env_set("bootcmd", boot_commond);
	debug("to be run cmd=%s\n", boot_commond);
	tick_printf("update bootcmd\n");
	return 0;
}

int sunxi_update_fdt_para_for_kernel(void)
{
	uint storage_type = 0;
	int ret = 0;
#ifdef CONFIG_SUNXI_SDMMC
	struct mmc *mmc = NULL;
	int dev_num = 0;
#endif

	storage_type = get_boot_storage_type_ext();

#ifdef CONFIG_SUNXI_SDMMC
	/* update sdhc dbt para */
	if (storage_type == STORAGE_EMMC || storage_type == STORAGE_EMMC3) {
		dev_num = (storage_type == STORAGE_EMMC) ? 2 : 3;
		mmc = find_mmc_device(dev_num);
		if (mmc == NULL) {
			printf("can't find valid mmc %d\n", dev_num);
			return -1;
		}
		if (mmc->cfg->sample_mode == AUTO_SAMPLE_MODE) {
			mmc_update_config_for_sdly(mmc);
		}
	}
#endif
	/* creat udc dbt para when in charger_mode */
	if (gd->chargemode == 1) {
		fdt_find_and_setprop(working_fdt, "/soc/udc-controller",
					"charger_mode", NULL, 0, 1);
	}

	/* fix nand&sdmmc */
	switch (storage_type) {
	case STORAGE_NAND:
#ifdef CONFIG_SUNXI_UBIFS
		if (nand_use_ubi() == 0)
#endif
		{
			fdt_enable_node("nand0", 1);
			fdt_enable_node("spi0", 0);
		}
		break;
	case STORAGE_SPI_NAND:
#ifdef CONFIG_SUNXI_UBIFS
		if (nand_use_ubi() == 0)
#endif
		{
			fdt_enable_node("spinand", 1);
			fdt_enable_node("spi0", 0);
		}
		break;
	case STORAGE_EMMC:
		fdt_enable_node("mmc2", 1);
		break;
	case STORAGE_EMMC3:
		fdt_enable_node("mmc3", 1);
		break;
	case STORAGE_SD:
		fdt_enable_node("mmc0", 1);
		{
			uint32_t dragonboard_test = 0;
			script_parser_fetch("/soc/target", "dragonboard_test",
						(int *)&dragonboard_test, 0);
			if (dragonboard_test == 1) {
				fdt_enable_node("mmc2", 1);
#ifdef CONFIG_SUNXI_SDMMC
				mmc_update_config_for_dragonboard(2);
#ifdef CONFIG_MMC3_SUPPORT
				mmc_update_config_for_dragonboard(3);
#endif
#endif
			}
		}
		break;
	case STORAGE_NOR:
		fdt_enable_node("/soc/spi", 1);
		break;
	default:
		break;
	}

#if defined(CONFIG_SUNXI_DRM_SUPPORT)
	ulong drm_base = 0, drm_size = 0;
	if (gd->securemode == SUNXI_SECURE_MODE_WITH_SECUREOS) {
		if (!smc_tee_probe_drm_configure(&drm_base, &drm_size)) {
			pr_msg("drm_base=0x%lx\n", drm_base);
			pr_msg("drm_size=0x%lx\n", drm_size);
			ret = fdt_add_mem_rsv(working_fdt, drm_base, drm_size);
			if (ret)
				pr_err("##add mem rsv error: %s : %s\n",
				       __func__, fdt_strerror(ret));
		}
	}
#endif

	/* fix dram para */
	ret = update_fdt_dram_para(working_fdt);
	if (ret < 0) {
		return -1;
	}
	tick_printf("update dts\n");
	return 0;
}

int sunxi_update_partinfo(void)
{
	int index, ret;
	char partition_sets[PARTITION_SETS_MAX_SIZE];
	char part_name[PARTITION_NAME_MAX_SIZE];
	char root_part_name[ROOT_PART_NAME_MAX_SIZE];
	char *root_partition;
	char blkoops_part_name[DEV_PART_NAME_MAX_SIZE];
	char *blkoops_partition;
	char *partition_index = partition_sets;
	int offset = 0;
	int temp_offset = 0;
	int storage_type = get_boot_storage_type();
	struct blk_desc *desc;
	disk_partition_t info = { 0 };

	memset(root_part_name, 0, ROOT_PART_NAME_MAX_SIZE);
	root_partition = env_get("root_partition");
	if (root_partition)
		printf("root_partition is %s\n", root_partition);

	memset(blkoops_part_name, 0, DEV_PART_NAME_MAX_SIZE);
	blkoops_partition = env_get("blkoops_partition");
	if (blkoops_partition)
		printf("blkoops_partition is %s\n", blkoops_partition);

	memset(partition_sets, 0, PARTITION_SETS_MAX_SIZE);
	desc = blk_get_devnum_by_typename("sunxi_flash", 0);
	if (desc == NULL)
		return -ENODEV;

	for (index = 1;; index++) {
		ret = part_get_info(desc, index, &info);
		debug("%s: try part %d, ret = %d\n", __func__, index, ret);
		if (ret < 0)
			break;

		memset(part_name, 0, PARTITION_NAME_MAX_SIZE);
		if (storage_type == STORAGE_NAND) {
			sprintf(part_name, "nand0p%d", index);
		} else if (storage_type == STORAGE_NOR) {
			sprintf(part_name, "mtdblock%d", index);
		} else {
			sprintf(part_name, "mmcblk0p%d", index);
		}

		temp_offset = strlen((char*)info.name) + strlen(part_name) + 2;
		if (temp_offset >= PARTITION_SETS_MAX_SIZE) {
			printf("partition_sets is too long, please reduces "
			       "partition name\n");
			break;
		}
		sprintf(partition_index, "%s@%s:", info.name, part_name);
		if (root_partition && strncmp(root_partition, (char *)info.name, sizeof(info.name)) == 0)
			sprintf(root_part_name, "/dev/%s", part_name);
		if (blkoops_partition && strncmp(blkoops_partition, (char *)info.name, sizeof(info.name)) == 0)
			sprintf(blkoops_part_name, "/dev/%s", part_name);
		offset += temp_offset;
		partition_index = partition_sets + offset;

	}
	partition_sets[offset - 1] = '\0';
	partition_sets[PARTITION_SETS_MAX_SIZE - 1] = '\0';
	env_set("partitions", partition_sets);

	if (*root_part_name != 0) {
		printf("set root to %s\n", root_part_name);
		if (storage_type == STORAGE_NAND)
			env_set("nand_root", root_part_name);
		else if (storage_type == STORAGE_NOR)
			env_set("nor_root", root_part_name);
		else
			env_set("mmc_root", root_part_name);
	}
	if (*blkoops_part_name != 0) {
		printf("set blkoops_blkdev to %s\n", blkoops_part_name);
		env_set("blkoops_blkdev", blkoops_part_name);
	}
	tick_printf("update part info\n");
	return 0;
}

int sunxi_force_rotpk(void)
{
	return ((uboot_spare_head.boot_data.func_mask &
		 UBOOT_FUNC_MASK_BIT_FORCE_ROTPK) ==
		UBOOT_FUNC_MASK_BIT_FORCE_ROTPK);
}

int sunxi_update_rotpk_info(void)
{
	char rotpk_status[16] = "";
	int ret;
	ret = sunxi_efuse_get_rotpk_status();
	if (ret >= 0) {
		sprintf(rotpk_status, "%d", ret);
		env_set("rotpk_status", rotpk_status);
	}

	if (sunxi_force_rotpk()) {
		if (ret < 1) {
			pr_err("rotpk required but not burned\n");
			return -1;
		}
	}
	return 0;
}