// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 Amlogic, Inc. All rights reserved.
 */

#include "key_manage_i.h"
#include "key_config.h"

static struct key_info_t unify_key_info={.key_num =0, .key_flag = 0};
static struct key_item_t *unifykey_item=NULL;

static int unifykey_item_verify_check(struct key_item_t *key_item)
{
	if (!key_item) {
		KM_ERR("unify key item is invalid\n");
		return -1;
	}

	if (key_item->dev == KEY_M_UNKNOWN_DEV || key_item->datFmt == KEY_M_MAX_DF) {
		KM_ERR("unify key item is invalid\n");
		return -1;
	}

	return 0;
}

static struct key_item_t *unifykey_find_item_by_name(const char *name)
{
	struct key_item_t *pre_item;
	int i = 0;
	const unsigned cnt = unify_key_info.key_num;

	for (pre_item = unifykey_item; i < cnt; ++pre_item, ++i) {
		if (!strcmp(pre_item->name, name))
			return pre_item;
	}

	KM_ERR("cannot find dev for keyname %s\n", name);
	return NULL;
}

enum key_manager_df_e keymanage_dts_get_key_fmt(const char *keyname)
{
	struct key_item_t *key_manage;
	enum key_manager_df_e keyValFmt = KEY_M_MAX_DF;

	if (!unify_key_info.key_flag) {
		KM_ERR("/unify not parsed yet!\n");
		return KEY_M_MAX_DF;
	}

	key_manage = unifykey_find_item_by_name(keyname);
	if (key_manage == NULL) {
		KM_ERR ("%s key name is not exist\n", keyname) ;
		return keyValFmt;
	}
	if (unifykey_item_verify_check(key_manage)) {
		KM_ERR ("%s key name is invalid\n", keyname) ;
		return keyValFmt;
	}

	keyValFmt = key_manage->datFmt;
	return keyValFmt;
}

//which device does the key stored in
enum key_manager_dev_e keymanage_dts_get_key_device(const char *keyname)
{
	struct key_item_t *key_manage;

	if (!unify_key_info.key_flag) {
		KM_ERR("/unify not parsed yet!\n");
		return KEY_M_MAX_DEV;
	}
	key_manage = unifykey_find_item_by_name(keyname);
	if (key_manage == NULL) {
		KM_ERR("%s key name is not exist\n",keyname);
		return KEY_M_MAX_DEV;
	}
	if (unifykey_item_verify_check(key_manage)) {
		KM_ERR("%s key name is invalid\n",keyname);
		return KEY_M_MAX_DEV;
	}

	return key_manage->dev;
}

int keymanage_get_permit_type(const char* keyname)
{
	struct key_item_t *key_manage;

    if (!unify_key_info.key_flag) {
		KM_ERR("/unify not parsed yet!\n");
		return -1;
	}
	key_manage = unifykey_find_item_by_name(keyname);
	if (key_manage == NULL) {
		KM_ERR("%s key name is not exist\n", keyname);
		return -1;
	}

	return key_manage->permit;
}

const char* keymanage_dts_get_key_type(const char* keyname)
{
	struct key_item_t *key_manage;

	if (!unify_key_info.key_flag) {
		KM_ERR("/unify not parsed yet!\n");
		return NULL;
	}
	key_manage = unifykey_find_item_by_name(keyname);
	if (key_manage == NULL) {
		KM_ERR("%s key name is not exist\n",keyname);
		return NULL;
	}

	return key_manage->keyType;
}

char unifykey_get_efuse_version(void)
{
	char ver=0;

    if (!unify_key_info.key_flag) {
        KM_ERR("/unify not parsed yet!\n");
        return 0;
    }

	if (unify_key_info.efuse_version != -1) {
		ver = (char)unify_key_info.efuse_version;
	}
	return ver;
}

const char* keymanage_dts_get_enc_type(const char* keyname)
{
	struct key_item_t *key_manage;

	if (!unify_key_info.key_flag) {
		KM_ERR("/unify not parsed yet!\n");
		return NULL;
	}
	key_manage = unifykey_find_item_by_name(keyname);
	if (key_manage == NULL) {
		KM_ERR("%s key name is not exist\n",keyname);
		return NULL;
	}

	return key_manage->encType;
}

#if CONFIG_TEE_CRYPTO_API
int keymanage_get_func_type(const char* keyname)
{
	struct key_item_t *key_manage;

    if (!unify_key_info.key_flag) {
        KM_ERR("/unify not parsed yet!\n");
        return -1;
    }
	key_manage = unifykey_find_item_by_name(keyname);
	if (key_manage == NULL) {
		KM_ERR("%s key name is not exist\n",keyname);
		return -1;
	}

	return key_manage->func;
}
#endif

int unifykey_get_encrypt_type(void)
{
	return unify_key_info.encrypt_type;
}

static int unifykey_item_parse(struct key_item_t *item, int id,char *item_path)
{
	struct key_item_t *temp_item=NULL;
	int count;

	temp_item = unifykey_item + id;

	if (item->encType[0] != '\0') {
		count = strlen(item->encType);
		if ( count > KEY_UNIFY_TYPE_LEN_MAX ) {
			KM_ERR("key-encrypt [%s] too long\n", item->encType);
			return __LINE__;
		}
		memcpy(temp_item->encType, (char*)item->encType, count);
	}

	if (item->name[0] != '\0') {
		count = strlen(item->name);
		if (count >= KEY_UNIFY_NAME_LEN) {
			KM_ERR("key-name strlen (%d) > max(%d) at key_%d\n", count, KEY_UNIFY_NAME_LEN - 1, id);
			return __LINE__;
		}
		memcpy(temp_item->name, item->name, count);
		temp_item->name[count] = 0;
	}
	temp_item->dev = item->dev;
	temp_item->permit = item->permit;
	temp_item->id = id;
	if (item->keyType[0] == '\0') //prop 'key-type' not configured, default to raw except special names
		strcpy(temp_item->keyType, "raw");
    else {
		const int keyTypeLen = strlen(item->keyType);
		if (keyTypeLen > KEY_UNIFY_TYPE_LEN_MAX) {
			KM_ERR("key[%s]cfg key-type[%s] sz %d > max %d\n", temp_item->name, item->keyType, keyTypeLen, KEY_UNIFY_TYPE_LEN_MAX);
			return __LINE__;
		}
		strcpy(temp_item->keyType, item->keyType);
	}
#if CONFIG_TEE_CRYPTO_API
	if (!item->func)
		temp_item->func = 0;
	else
		temp_item->func = item->func;
#endif

	KM_DBG("key[%02d] keyname %s, %d\n", id, temp_item->name, temp_item->dev);

	return 0;
}

static int unifykey_item_create(int num)
{
    int ret = 0;
    int i;
    char item_path[100];

    for (i=0;i<num;i++) {
		sprintf(item_path, "/unifykey/key_%d", i);
		struct key_item_t *item = &amlkeys[i];
		ret = unifykey_item_parse(item, i, item_path);
		if (ret) {
			KM_ERR("Fail at parse %s\n", item_path);
			return __LINE__;
		}
	}

	//	printf("unifykey-num fact is %x\n",count);
	return 0;
}

//parse and cache the dts cfg
//TODO: check keys names has no duplicated
int keymanage_dts_parse(const void* dt_addr)
{
	int ret = 0;

	unify_key_info.key_num = KEYNUM;
	KM_MSG("key_num: %d\n", unify_key_info.key_num);

	if (unify_key_info.key_num <= 0) {
		KM_ERR("unifykey-num is not configured\n");
		return __LINE__;
	}
	if (unify_key_info.key_num > 256) {
		KM_ERR("Cfg key_num is %d > 32,pls check!\n", unify_key_info.key_num);
		return __LINE__;
	}

	unify_key_info.encrypt_type = -1;

	if (unifykey_item) {
		free(unifykey_item);
	}
	const unsigned keyInfBufLen = unify_key_info.key_num * sizeof(struct key_item_t);
	unifykey_item = (struct key_item_t*)malloc(keyInfBufLen);
	memset(unifykey_item, 0 , keyInfBufLen);

	ret = unifykey_item_create(unify_key_info.key_num);
	unify_key_info.key_flag = ret ? 0 : 1;

	return ret;
}