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

#include <common.h>
#include <fastboot.h>
#include <fastboot-internal.h>
#include <fb_mmc.h>
#include <fb_nand.h>
#include <fs.h>
#include <version.h>
#include <partition_table.h>

static void getvar_version(char *var_parameter, char *response);
static void getvar_bootloader_version(char *var_parameter, char *response);
static void getvar_downloadsize(char *var_parameter, char *response);
static void getvar_serialno(char *var_parameter, char *response);
static void getvar_version_baseband(char *var_parameter, char *response);
static void getvar_hw_revision(char *var_parameter, char *response);
static void getvar_off_mode_charge(char *var_parameter, char *response);
static void getvar_variant(char *var_parameter, char *response);
static void getvar_battery_soc_ok(char *var_parameter, char *response);
static void getvar_battery_voltage(char *var_parameter, char *response);
static void getvar_block_size(char *var_parameter, char *response);
static void getvar_secure(char *var_parameter, char *response);
static void getvar_unlocked(char *var_parameter, char *response);
static void getvar_is_userspace(char *var_parameter, char *response);
static void getvar_is_logical(char *var_parameter, char *response);
static void getvar_slot_count(char *var_parameter, char *response);
static void getvar_super_partition_name(char *var_parameter, char *response);
static void getvar_snapshot_update_status(char *var_parameter, char *response);

static void getvar_product(char *var_parameter, char *response);
static void getvar_current_slot(char *var_parameter, char *response);
static void getvar_slot_suffixes(char *var_parameter, char *response);
static void getvar_has_slot(char *var_parameter, char *response);
#ifdef CONFIG_G_AB_SYSTEM
static void getvar_slot_successful(char *var_parameter, char *response);
static void getvar_slot_unbootable(char *var_parameter, char *response);
static void getvar_slot_retry_count(char *var_parameter, char *response);
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
static void getvar_partition_type(char *part_name, char *response);
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
static void getvar_partition_type(char *part_name, char *response);
static void getvar_partition_size(char *part_name, char *response);
#endif

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


static const struct {
	const char *variable;
	void (*dispatch)(char *var_parameter, char *response);
} getvar_dispatch[] = {
	{
		.variable = "version",
		.dispatch = getvar_version
	}, {
		.variable = "bootloader-version",
		.dispatch = getvar_bootloader_version
	}, {
		.variable = "version-bootloader",
		.dispatch = getvar_bootloader_version
	}, {
		.variable = "off-mode-charge",
		.dispatch = getvar_off_mode_charge
	}, {
		.variable = "hw-revision",
		.dispatch = getvar_hw_revision
	}, {
		.variable = "variant",
		.dispatch = getvar_variant
	}, {
		.variable = "battery-soc-ok",
		.dispatch = getvar_battery_soc_ok
	}, {
		.variable = "battery-voltage",
		.dispatch = getvar_battery_voltage
	}, {
		.variable = "erase-block-size",
		.dispatch = getvar_block_size
	}, {
		.variable = "logical-block-size",
		.dispatch = getvar_block_size
	}, {
		.variable = "secure",
		.dispatch = getvar_secure
	}, {
		.variable = "unlocked",
		.dispatch = getvar_unlocked
	}, {
		.variable = "is-userspace",
		.dispatch = getvar_is_userspace
	}, {
		.variable = "is-logical",
		.dispatch = getvar_is_logical
	}, {
		.variable = "super-partition-name",
		.dispatch = getvar_super_partition_name
	}, {
		.variable = "downloadsize",
		.dispatch = getvar_downloadsize
	}, {
		.variable = "max-download-size",
		.dispatch = getvar_downloadsize
	}, {
		.variable = "serialno",
		.dispatch = getvar_serialno
	}, {
		.variable = "version-baseband",
		.dispatch = getvar_version_baseband
	}, {
		.variable = "product",
		.dispatch = getvar_product
	}, {
		.variable = "current-slot",
		.dispatch = getvar_current_slot
	}, {
		.variable = "slot-count",
		.dispatch = getvar_slot_count
	}, {
		.variable = "slot-suffixes",
		.dispatch = getvar_slot_suffixes
	}, {
		.variable = "snapshot-update-status",
		.dispatch = getvar_snapshot_update_status
	}, {
		.variable = "has-slot",
		.dispatch = getvar_has_slot
#ifdef CONFIG_G_AB_SYSTEM
	}, {
		.variable = "slot-successful",
		.dispatch = getvar_slot_successful
	}, {
		.variable = "slot-unbootable",
		.dispatch = getvar_slot_unbootable
	}, {
		.variable = "slot-retry-count",
		.dispatch = getvar_slot_retry_count
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
	}, {
		.variable = "partition-type",
		.dispatch = getvar_partition_type
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
	}, {
		.variable = "partition-size",
		.dispatch = getvar_partition_size
#endif
	}
};

static void getvar_version(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_response("INFOversion: ", response, "%s", FASTBOOT_VERSION);
	else
		fastboot_okay(FASTBOOT_VERSION, response);
}

static void getvar_bootloader_version(char *var_parameter, char *response)
{
	char s_version[32];
	strncpy(s_version, "01.01.", 6);
	strcat(s_version, U_BOOT_BUILD_DATE);
	printf("s_version: %s\n", s_version);
	if (busy_flag == 1) {
		fastboot_response("INFOversion-bootloader: ", response, "%s", s_version);
	} else
		fastboot_okay(s_version, response);
}

static void getvar_hw_revision(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("hw-revision: 0", response);
	else
		fastboot_okay("0", response);
}

static void getvar_off_mode_charge(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("off-mode-charge: 0", response);
	else
		fastboot_okay("0", response);
}

static void getvar_variant(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("variant: US", response);
	else
		fastboot_okay("US", response);
}

static void getvar_battery_soc_ok(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("battery-soc-ok: yes", response);
	else
		fastboot_okay("yes", response);
}

static void getvar_battery_voltage(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("battery-voltage: 4", response);
	else
		fastboot_okay("4", response);
}

static void getvar_block_size(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("block-size: 2000", response);
	else
		fastboot_okay("2000", response);
}

static void getvar_secure(char *var_parameter, char *response)
{
	if (check_lock()) {
		if (busy_flag == 1)
			fastboot_busy("secure: yes", response);
		else
			fastboot_okay("yes", response);
	} else {
		if (busy_flag == 1)
			fastboot_busy("secure: no", response);
		else
			fastboot_okay("no", response);
	}
}

static void getvar_unlocked(char *var_parameter, char *response)
{
	if (check_lock()) {
		if (busy_flag == 1)
			fastboot_busy("secure: no", response);
		else
			fastboot_okay("no", response);
	} else {
		if (busy_flag == 1)
			fastboot_busy("secure: yes", response);
		else
			fastboot_okay("yes", response);
	}
}

static void getvar_is_userspace(char *var_parameter, char *response)
{
	if (dynamic_partition) {
		if (busy_flag == 1)
			fastboot_busy("is-userspace: no", response);
		else
			fastboot_okay("no", response);
	} else {
		if (busy_flag == 1)
			fastboot_busy("is-userspace: do not use dynamic", response);
		else
			fastboot_fail("do not use dynamic", response);
	}
}

static void getvar_super_partition_name(char *var_parameter, char *response)
{
	char *slot_name;
	slot_name = env_get("slot-suffixes");
	char name[64];
	if (has_boot_slot == 0) {
		strncpy(name, "super-partition-name: super", 64);
	} else {
		printf("slot-suffixes: %s\n", slot_name);
		if (strcmp(slot_name, "0") == 0) {
			strncpy(name, "super-partition-name: super_a", 64);
		} else if (strcmp(slot_name, "1") == 0) {
			strncpy(name, "super-partition-name: super_b", 64);
		}
	}
	if (busy_flag == 1)
		fastboot_busy(name, response);
	else
		fastboot_okay(name, response);
}

static void getvar_is_logical(char *var_parameter, char *response)
{
	char name[64] = {0};
	strncpy(name, var_parameter, strnlen(var_parameter, 64));
	name[63] = 0;
	if (has_boot_slot == 1) {
		char *slot_name;
		slot_name = env_get("slot-suffixes");
		if ((strcmp(var_parameter, "system") == 0) || (strcmp(var_parameter, "vendor") == 0)
			|| (strcmp(var_parameter, "odm") == 0) || (strcmp(var_parameter, "product") == 0)
			|| (strcmp(var_parameter, "system_ext") == 0) || (strcmp(var_parameter, "dtbo") == 0)
			|| (strcmp(var_parameter, "boot") == 0) || (strcmp(var_parameter, "recovery") == 0)
			|| (strcmp(var_parameter, "vendor_boot") == 0) || (strcmp(var_parameter, "vbmeta") == 0)) {
			if (strcmp(slot_name, "0") == 0) {
				strcat(name, "_a");
			} else if (strcmp(slot_name, "1") == 0) {
				strcat(name, "_b");
			}
		}
	}
	printf("partition name is %s\n", name);

	if (!dynamic_partition) {
		if (busy_flag == 1)
			fastboot_response("INFOis_logical:", response, "%s: no", var_parameter);
		else
			fastboot_okay("no", response);
	} else {
		if (busy_flag == 1) {
#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK
			if (is_partition_logical(name) == 0) {
				printf("%s is logic partition\n", name);
				fastboot_response("INFOis_logical:", response, "%s: yes", name);
			} else {
				fastboot_response("INFOis_logical:", response, "%s: no", name);
			}
#else
			fastboot_response("INFOis_logical:", response, "%s: no", name);
#endif
		} else {
#ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK
				if (is_partition_logical(name) == 0) {
					printf("%s is logic partition\n", name);
					fastboot_okay("yes", response);
				} else {
					fastboot_okay("no", response);
				}
#else
				fastboot_okay("no", response);
#endif
		}
	}
}

static void getvar_slot_count(char *var_parameter, char *response)
{
#ifdef CONFIG_G_AB_SYSTEM
	fastboot_okay("2", response);
#else
	if (has_boot_slot == 1) {
		if (busy_flag == 1)
			fastboot_busy("slot-count: 2", response);
		else
			fastboot_okay("2", response);
	}
	else {
		if (busy_flag == 1)
			fastboot_busy("slot-count: 0", response);
		else
			fastboot_okay("0", response);
	}
#endif
}

static void getvar_downloadsize(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_response("INFOdownloadsize: ", response, "0x%08x", fastboot_buf_size);
	else
		fastboot_response("OKAY", response, "0x%08x", fastboot_buf_size);
}

static void getvar_serialno(char *var_parameter, char *response)
{
	const char *tmp = env_get("serial#");

	if (busy_flag == 1) {
		if (tmp)
			fastboot_response("INFOserialno: ", response, "%s", tmp);
		else
			fastboot_busy("serialno: Value not set", response);
	} else {
		if (tmp)
			fastboot_okay(tmp, response);
		else
			fastboot_fail("Value not set", response);
	}
}

static void getvar_version_baseband(char *var_parameter, char *response)
{
	if (busy_flag == 1)
		fastboot_busy("version-baseband: N/A", response);
	else
		fastboot_okay("N/A", response);
}

static void getvar_product(char *var_parameter, char *response)
{
	const char *board = env_get("board");

	if (busy_flag == 1) {
		if (board)
			fastboot_response("INFOproduct: ", response, "%s", board);
		else
			fastboot_busy("product: Board not set", response);
	} else {
		if (board)
			fastboot_okay(board, response);
		else
			fastboot_fail("Board not set", response);
	}
}

static void getvar_current_slot(char *var_parameter, char *response)
{
	char *slot;
	slot = env_get("slot-suffixes");
	printf("slot-suffixes: %s\n", slot);
	/* A/B not implemented, for now always return _a */
#ifdef CONFIG_G_AB_SYSTEM
	const char *s = env_get("active_slot");
	printf("active_slot: %s\n", s);
	fastboot_okay(s, response);
#else
	if (busy_flag == 1) {
		if (strcmp(slot, "0") == 0)
			fastboot_busy("current-slot: a", response);
		else if (strcmp(slot, "1") == 0)
			fastboot_busy("current-slot: b", response);
	}
	else {
		if (strcmp(slot, "0") == 0)
			fastboot_okay("a", response);
		else if (strcmp(slot, "1") == 0)
			fastboot_okay("b", response);
	}
#endif
}

static void getvar_snapshot_update_status(char *var_parameter, char *response)
{
	struct misc_virtual_ab_message message;
	get_mergestatus(&message);
	if (busy_flag == 1) {
		if (has_boot_slot == 1) {
			switch (message.merge_status) {
				case SNAPSHOTTED:
					fastboot_busy("snapshotted", response);
					break;
				case MERGING:
					fastboot_busy("merging", response);
					break;
				default:
					fastboot_busy("none", response);
					break;
			}
		} else
			fastboot_busy("none", response);
	}
	else {
		if (has_boot_slot == 1) {
			switch (message.merge_status) {
				case SNAPSHOTTED:
					fastboot_okay("snapshotted", response);
					break;
				case MERGING:
					fastboot_okay("merging", response);
					break;
				default:
					fastboot_okay("none", response);
					break;
			}
		} else
			fastboot_fail("not ab mode", response);
	}
}

static void getvar_slot_suffixes(char *var_parameter, char *response)
{
	char *s;
	s = env_get("slot-suffixes");
	printf("slot-suffixes: %s\n", s);
	if (busy_flag == 1) {
		if (!strcmp(s, "-1") == 0)
			fastboot_response("INFOslot-suffixes:", response, "%s", s);
		else
			fastboot_busy("slot-suffixes: 0", response);
	}
	else {
		if (!strcmp(s, "-1") == 0)
			fastboot_okay(s, response);
		else
			fastboot_okay("0", response);
	}
}

static void getvar_has_slot(char *part_name, char *response)
{
#ifdef CONFIG_G_AB_SYSTEM
	if (part_name && (!strcmp(part_name, "boot") ||
			  !strcmp(part_name, "system") ||
			  !strcmp(part_name, "tpl") ||
			  !strcmp(part_name, "rtos")))
#else
	if (part_name && (!strcmp(part_name, "boot") ||
			  !strcmp(part_name, "system")))
#endif
		fastboot_okay("yes", response);
	else
		fastboot_okay("no", response);
}

#ifdef CONFIG_G_AB_SYSTEM
static void getvar_slot_successful(char *var_parameter, char *response)
{
	char str[128];
	int ret;

	if (var_parameter && (!strcmp(var_parameter, "a") ||
			  !strcmp(var_parameter, "b"))) {
		sprintf(str, "get_slot_state %s successful", var_parameter);
		printf("command:    %s\n", str);
		ret = run_command(str, 0);
		printf("ret = %d\n", ret);
		if (ret == 0)
			fastboot_okay("no", response);
		else
			fastboot_okay("yes", response);
	} else {
		fastboot_okay("unknow slot", response);
	}
}

static void getvar_slot_unbootable(char *var_parameter, char *response)
{
	char str[128];
	int ret;

	if (var_parameter && (!strcmp(var_parameter, "a") ||
			  !strcmp(var_parameter, "b"))) {
		sprintf(str, "get_slot_state %s unbootable", var_parameter);
		printf("command:    %s\n", str);
		ret = run_command(str, 0);
		printf("ret = %d\n", ret);
		if (ret == 0)
			fastboot_okay("yes", response);
		else
			fastboot_okay("no", response);
	} else {
		fastboot_okay("unknow slot", response);
	}
}

static void getvar_slot_retry_count(char *var_parameter, char *response)
{
	char str[128];
	char str_num[12];
	char *retry_count;
	int ret;

	if (var_parameter && (!strcmp(var_parameter, "a") ||
			  !strcmp(var_parameter, "b"))) {
		sprintf(str, "get_slot_state %s retry-count", var_parameter);
		printf("command:    %s\n", str);
		ret = run_command(str, 0);
		printf("ret = %d\n", ret);

		retry_count = env_get("cur_retry_count");
		strcpy(str_num, retry_count);
		fastboot_okay(str_num, response);
	} else {
		fastboot_okay("unknow slot", response);
	}
}
#endif

#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
static void getvar_partition_type(char *part_name, char *response)
{
	/*int r;
	struct blk_desc *dev_desc;
	disk_partition_t part_info;

	r = fastboot_mmc_get_part_info(part_name, &dev_desc, &part_info,
				       response);
	if (r >= 0) {
		r = fs_set_blk_dev_with_part(dev_desc, r);
		if (r < 0) {
			if (busy_flag == 1)
				fastboot_response("INFOpartition-type:", response, "%s: failed to set partition", part_name);
			else
				fastboot_fail("failed to set partition", response);
		} else {
			if (busy_flag == 1)
				fastboot_busy(fs_get_type_name(), response);
			else
				fastboot_okay(fs_get_type_name(), response);
		}
	}*/
	if ((strcmp(part_name, "system") == 0) || (strcmp(part_name, "vendor") == 0)
			|| (strcmp(part_name, "odm") == 0) || (strcmp(part_name, "product") == 0)
			|| (strcmp(part_name, "system_ext") == 0) || (strcmp(part_name, "dtbo") == 0)
			|| (strcmp(part_name, "metadata") == 0) || (strcmp(part_name, "vbmeta") == 0)
			|| (strcmp(part_name, "data") == 0) || (strcmp(part_name, "userdata") == 0)){
		if (busy_flag == 1)
			fastboot_response("INFOpartition-type:", response, "%s: ext4", part_name);
		else
			fastboot_okay("ext4", response);
	} else if (strcmp(part_name, "cache") == 0) {
		if (has_boot_slot == 0) {
			if (busy_flag == 1)
				fastboot_response("INFOpartition-type:", response, "%s: ext4", part_name);
			else
				fastboot_okay("ext4", response);
		}
	} else {
		if (busy_flag == 1)
			fastboot_response("INFOpartition-type:", response, "%s: raw", part_name);
		else
			fastboot_okay("raw", response);
	}
}

static void getvar_partition_size(char *part_name, char *response)
{
	int r;
	size_t size;
	char name[32];

	if (strcmp(part_name, "userdata") == 0 && !vendor_boot_partition)
		strncpy(name, "data", 4);
	else if (strcmp(part_name, "data") == 0 && vendor_boot_partition)
		strncpy(name, "userdata", 8);
	else
		strncpy(name, part_name, 32);

#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC)
	struct blk_desc *dev_desc;
	disk_partition_t part_info;

	r = fastboot_mmc_get_part_info(name, &dev_desc, &part_info,
				       response);
	if (r >= 0)
		size = part_info.size * 512;
#endif
#if CONFIG_IS_ENABLED(FASTBOOT_FLASH_NAND)
	struct part_info *part_info;

	r = fastboot_nand_get_part_info(name, &part_info, response);
	if (r >= 0)
		size = part_info->size * 512;
#endif
	if (r >= 0) {
		if (busy_flag == 1) {
			char name[64];
			strncpy(name, "INFOpartition-size:", 64);
			strcat(name, part_name);
			strcat(name, ": ");
			fastboot_response(name, response, "0x%016zx", size);
		}
		else
			fastboot_response("OKAY", response, "0x%016zx", size);
	}
}
#endif

/**
 * fastboot_getvar() - Writes variable indicated by cmd_parameter to response.
 *
 * @cmd_parameter: Pointer to command parameter
 * @response: Pointer to fastboot response buffer
 *
 * Look up cmd_parameter first as an environment variable of the form
 * fastboot.<cmd_parameter>, if that exists return use its value to set
 * response.
 *
 * Otherwise lookup the name of variable and execute the appropriate
 * function to return the requested value.
 */
void fastboot_getvar(char *cmd_parameter, char *response)
{
	if (!cmd_parameter) {
		fastboot_fail("missing var", response);
	} else {
#define FASTBOOT_ENV_PREFIX	"fastboot."
		int i;
		char *var_parameter = cmd_parameter;
		char envstr[FASTBOOT_RESPONSE_LEN];
		const char *s;

		snprintf(envstr, sizeof(envstr) - 1,
			 FASTBOOT_ENV_PREFIX "%s", cmd_parameter);
		s = env_get(envstr);
		if (s) {
			fastboot_response("OKAY", response, "%s", s);
			return;
		}

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

		strsep(&var_parameter, ":");
		for (i = 0; i < ARRAY_SIZE(getvar_dispatch); ++i) {
			if (!strcmp(getvar_dispatch[i].variable,
				    cmd_parameter)) {
				getvar_dispatch[i].dispatch(var_parameter,
							    response);
				return;
			}
		}
		pr_warn("WARNING: unknown variable: %s\n", cmd_parameter);
		fastboot_fail("Variable not implemented", response);
	}
}