/*
 * Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *    1. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *    2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the
 *       distribution.
 *    3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
 *       its contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "cmd_util.h"
#include "driver/chip/hal_prcm.h"
#include "sdd/sdd.h"

#if PRJCONF_NET_EN
#include "common/framework/net_ctrl.h"
#include "net/wlan/wlan_ext_req.h"
#include "net/wlan/wlan_defs.h"

char *rate_tab_name[11] = {
	"DSSS         1,2",
	"CCK       5.5,11",
	"BPSK1/2    6,6.5",
	"BPSK3/4        9",
	"QPSK1/2    12,13",
	"QPSK3/4  18,19.5",
	"16QAM1/2   24,26",
	"16QAM3/4   36,39",
	"64QAM2/3   48,52",
	"64QAM3/4 54,58.5",
	"64QAM5/6      65"
};

/*
 * print_type:0-HEX type, 1-ASCII type
 */
enum cmd_status cmd_rf_get_sdd_file_exec(char *cmd)
{
	int ret;
	int print_type;

	if (!strcmp("hex", cmd)) {
		print_type = 0;
	} else if (!strcmp("ascii", cmd)) {
		print_type = 1;
	} else {
		CMD_LOG(1, "Invalid params input!Should be [hex | ascii] !\n");
		return -1;
	}

	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_GET_SDD_FILE,
	                       (uint32_t)(&print_type));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}
	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_get_power_exec(char *cmd)
{
	int ret, i;
	int begin_rate, end_rate;
	wlan_ext_power_level_tab_get_t param;

	if (!strcmp("11b", cmd)) {
		begin_rate = 0;
		end_rate   = 1;
	} else if (!strcmp("11gn", cmd)) {
		begin_rate = 2;
		end_rate   = 9;
	} else if (!strcmp("11n_mcs7", cmd)) {
		begin_rate = 10;
		end_rate   = 10;
	} else if (!strcmp("all", cmd)) {
		begin_rate = 0;
		end_rate   = 10;
	} else {
		CMD_LOG(1, "Invalid params input!Should be "
		        "[11b | 11gn | 11n_mcs7 | all] !\n");
		return CMD_STATUS_INVALID_ARG;
	}

	CMD_LOG(1, "------------ power level tab current ------------\n");
	param.PowerTabType = POWER_LEVEL_TAB_TYPE_CUR;
	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_GET_POWER_LEVEL_TAB,
	                       (uint32_t)(&param));
	for (i = begin_rate; i <= end_rate; i++) {
		CMD_LOG(1, "%s: %d\n", rate_tab_name[i],
		        param.PowerTab[i] * 4 / 10 + 2);
	}
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}
	return CMD_STATUS_ACKED;
}

enum cmd_status cmd_rf_set_power_exec(char *cmd)
{
	int ret, cnt, i;
	int begin_rate, end_rate;
	int power_b = 0, power_gn = 0, power_mcs7 = 0;
	wlan_ext_power_level_tab_get_t param_get;
	wlan_ext_power_level_tab_set_t param_set;
	struct netif *nif;

	if (!strncmp("11b ", cmd, 4)) {
		begin_rate = 0;
		end_rate = 1;
		cnt = cmd_sscanf(cmd + 4, "%d", &power_b);
		if (cnt != 1) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else if (!strncmp("11gn ", cmd, 5)) {
		begin_rate = 2;
		end_rate = 9;
		cnt = cmd_sscanf(cmd + 5, "%d", &power_gn);
		if (cnt != 1) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else if (!strncmp("11n_mcs7 ", cmd, 9)) {
		begin_rate = 10;
		end_rate = 10;
		cnt = cmd_sscanf(cmd + 9, "%d", &power_mcs7);
		if (cnt != 1) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else if (!strncmp("all ", cmd, 4)) {
		begin_rate = 0;
		end_rate = 10;
		cnt = cmd_sscanf(cmd + 4, "%d %d %d",
		                 &power_b, &power_gn, &power_mcs7);
		if (cnt != 3) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else {
		CMD_LOG(1, "Invalid params input!Should be "
		        "[11b | 11gn | 11n_mcs7 | all] !\n");
		return -1;
	}

	nif = wlan_netif_get(WLAN_MODE_NONE);
	param_get.PowerTabType = POWER_LEVEL_TAB_TYPE_CUR;
	ret = wlan_ext_request(nif, WLAN_EXT_CMD_GET_POWER_LEVEL_TAB,
	                       (uint32_t)(&param_get));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}

	for (i = begin_rate; i <= end_rate; i++) {
		if (i >= 0 && i < 2)
			param_get.PowerTab[i] = (power_b - 2) * 10 / 4;
		else if (i >= 2 && i < 10)
			param_get.PowerTab[i] = (power_gn - 2) * 10 / 4;
		else
			param_get.PowerTab[i] = (power_mcs7 - 2) * 10 / 4;
	}
	cmd_memcpy(param_set.PowerTab, param_get.PowerTab,
	           POWER_LEVEL_TAB_USE_LENGTH * sizeof(uint16_t));
	ret = wlan_ext_request(nif, WLAN_EXT_CMD_SET_POWER_LEVEL_TAB,
	                       (uint32_t)(&param_set));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}
	CMD_LOG(1, "Set user power level:\n");
	for (i = 0; i < 11; i++) {
		CMD_LOG(1, "%s\t%d\n", rate_tab_name[i],
		        (int)(param_set.PowerTab[i] * 4 / 10 + 2));
	}

	return CMD_STATUS_ACKED;
}

enum cmd_status cmd_rf_get_sdd_power_exec(char *cmd)
{
	int ret;
	int begin_rate, end_rate;
	uint16_t user_power[13];

	if (!strcmp("11b", cmd)) {
		begin_rate = 0;
		end_rate = 1;
	} else if (!strcmp("11gn", cmd)) {
		begin_rate = 2;
		end_rate = 9;
	} else if (!strcmp("11n_mcs7", cmd)) {
		begin_rate = 10;
		end_rate = 10;
	} else if (!strcmp("all", cmd)) {
		begin_rate = 0;
		end_rate = 10;
	} else {
		CMD_LOG(1, "Invalid params input!Should be "
		        "[11b | 11gn | 11n_mcs7 | all] !\n");
		return -1;
	}

	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_GET_SDD_POWER,
	                       (uint32_t)(user_power));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}
	CMD_LOG(1, "Get sdd user power level:\n");
	for (int i = begin_rate; i <= end_rate; i++) {
		CMD_LOG(1, "%s\t%d\n", rate_tab_name[i],
		        (int)(user_power[i] * 4 / 16 + 2));
	}
	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_set_sdd_power_exec(char *cmd)
{
	int ret, cnt, i;
	int begin_rate, end_rate;
	uint16_t user_power[13];
	int power_b = 0, power_gn = 0, power_mcs7 = 0;
	struct netif *nif;

	if (!strncmp("11b ", cmd, 4)) {
		begin_rate = 0;
		end_rate = 1;
		cnt = cmd_sscanf(cmd + 4, "%d", &power_b);
		if (cnt != 1) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else if (!strncmp("11gn ", cmd, 5)) {
		begin_rate = 2;
		end_rate = 9;
		cnt = cmd_sscanf(cmd + 5, "%d", &power_gn);
		if (cnt != 1) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else if (!strncmp("11n_mcs7 ", cmd, 9)) {
		begin_rate = 10;
		end_rate = 10;
		cnt = cmd_sscanf(cmd + 9, "%d", &power_mcs7);
		if (cnt != 1) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else if (!strncmp("all ", cmd, 4)) {
		begin_rate = 0;
		end_rate = 10;
		cnt = cmd_sscanf(cmd + 4, "%d %d %d",
			&power_b, &power_gn, &power_mcs7);
		if (cnt != 3) {
			CMD_ERR("cnt %d\n", cnt);
			return CMD_STATUS_INVALID_ARG;
		}
	} else {
		CMD_LOG(1, "Invalid params input!Should be "
		        "[11b | 11gn | 11n_mcs7 | all] !\n");
		return -1;
	}

	nif = wlan_netif_get(WLAN_MODE_NONE);
	ret = wlan_ext_request(nif, WLAN_EXT_CMD_GET_SDD_POWER,
	                       (uint32_t)(user_power));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}

	for (i = begin_rate; i <= end_rate; i++) {
		if (i >= 0 && i < 2)
			user_power[i] = (power_b - 2) * 16 / 4;
		else if (i >= 2 && i < 10)
			user_power[i] = (power_gn - 2) * 16 / 4;
		else
			user_power[i] = (power_mcs7 - 2) * 16 / 4;
	}

	ret = wlan_ext_request(nif, WLAN_EXT_CMD_SET_SDD_POWER,
	                       (uint32_t)(user_power));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}
	CMD_LOG(1, "Set sdd user power level:\n");
	for (i = 0; i < 11; i++) {
		CMD_LOG(1, "%s\t%d\n", rate_tab_name[i],
		        (int)(user_power[i] * 4 / 16 + 2));
	}
	return CMD_STATUS_OK;
}

static enum cmd_status cmd_rf_set_channel_fec(char *cmd)
{
	int ret, cnt;
	int ch1, ch7, ch13;
	wlan_ext_channel_fec_set_t param;

	cnt = cmd_sscanf(cmd, "%d %d %d", &ch1, &ch7, &ch13);
	if (cnt != 3) {
		CMD_ERR("cnt %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}

	param.FecChannel1  = ch1  * 2;
	param.FecChannel7  = ch7  * 2;
	param.FecChannel13 = ch13 * 2;
	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_SET_CHANNEL_FEC,
	                       (uint32_t)(&param));
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}

	return CMD_STATUS_OK;
}

typedef struct sdd_xtal_cal_params {
	uint8_t id;
	uint8_t len;
	uint16_t reserve;
	uint32_t reserve1;
	s64_t   param1;
	s64_t   param2;
	s64_t   param3;
	s64_t   param4;
} sdd_xtal_cal_params_t;

typedef struct sdd_trim_temp {
	uint8_t id;
	uint8_t len;
	uint16_t reserve;
	uint32_t Temp0;
} sdd_trim_temp_t;

enum cmd_status cmd_rf_set_xtal_cal_params_exec(char *cmd)
{
	int ret, cnt;
	float param[4];
	wlan_ext_xtal_calib_params_set_t param_set;
	/* get param */
	cnt = cmd_sscanf(cmd, "%f %f %f %f", &param[0], &param[1], &param[2], &param[3]);

	/* check param */
	if (cnt != 4) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}

	param_set.param1_value = (s64_t)(param[0] * 10);
	param_set.param2_value = (s64_t)(param[1] * 10);
	param_set.param3_value = (s64_t)(param[2] * 10);
	param_set.param4_value = (s64_t)(param[3] * 10);
	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_SET_XTAL_CAL_PARAMS,
	                       (uint32_t)(&param_set));

	CMD_LOG(1, "set param1=%.1f, param2=%.1f, param3=%.1f, param4=%.1f\n", param[0], param[1], param[2], param[3]);
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_set_sdd_xtal_cal_params_exec(char *cmd)
{
	int ret, cnt;
	float param[4];
	sdd_xtal_cal_params_t param_sdd;
	struct sdd sdd;
	/* get param */
	cnt = cmd_sscanf(cmd, "%f %f %f %f", &param[0], &param[1], &param[2], &param[3]);

	/* check param */
	if (cnt != 4) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}

	param_sdd.param1 = (s64_t)(param[0] * 10);
	param_sdd.param2 = (s64_t)(param[1] * 10);
	param_sdd.param3 = (s64_t)(param[2] * 10);
	param_sdd.param4 = (s64_t)(param[3] * 10);

	ret = sdd_request(&sdd);
	if (ret == 0) {
		CMD_ERR("sdd not found!\n");
		return CMD_STATUS_ACKED;
	}
	if (sdd_set_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID, SDD_XTAL_TRIM_CALIB_PARAMS_ELT_ID, (uint8_t *)&(param_sdd.reserve))) {
		CMD_ERR("fail to set ie %d\n", SDD_XTAL_TRIM_CALIB_PARAMS_ELT_ID);
		return CMD_STATUS_ACKED;
	}
	if (sdd_save(&sdd)) {
		CMD_ERR("fail to save sdd to flash\n");
		return CMD_STATUS_ACKED;
	}
	CMD_LOG(1, "set param1=%.1f, param2=%.1f, param3=%.1f, param4=%.1f\n", param[0], param[1], param[2], param[3]);

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_get_sdd_xtal_cal_params_exec(char *cmd)
{
	int ret;
	sdd_xtal_cal_params_t param_sdd;
	struct sdd sdd;

	ret = sdd_request(&sdd);
	if (ret > 0) {
		struct sdd_ie *ie = sdd_get_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID,
		                               SDD_XTAL_TRIM_CALIB_PARAMS_ELT_ID);
		memcpy(&(param_sdd.reserve), ie->data, ie->length);
		CMD_LOG(1, "length is :%d\n", ie->length);
		sdd_release(&sdd);
	} else {
		CMD_ERR("sdd not found!\n");
		return CMD_STATUS_ACKED;
	}

	CMD_LOG(1, "param1 is :%.1f\n", ((float)param_sdd.param1 / 10));
	CMD_LOG(1, "param2 is :%.1f\n", ((float)param_sdd.param2 / 10));
	CMD_LOG(1, "param3 is :%.1f\n", ((float)param_sdd.param3 / 10));
	CMD_LOG(1, "param4 is :%.1f\n", ((float)param_sdd.param4 / 10));

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_set_trim_temp_exec(char *cmd)
{
	int ret, cnt;
	float Temp0;
	uint32_t Trim0;
	wlan_ext_trim_temp_set_t param_set;

	/* get param */
	cnt = cmd_sscanf(cmd, "%d %f", &Trim0, &Temp0);

	/* check param */
	if (cnt != 2) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}

	if (Trim0 > 127) {
		CMD_ERR("invalid Trim0 %d\n", Trim0);
		return CMD_STATUS_INVALID_ARG;
	}

	HAL_PRCM_SetDcxoFreqTrim(Trim0);
	CMD_LOG(1, "freq offset is set to %d!\n", Trim0);

	param_set.trim0_value = Trim0;
	param_set.temp0_value = (uint32_t)(Temp0 * 10);
	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_SET_TRIM_TEMP,
	                       (uint32_t)(&param_set));

	CMD_LOG(1, "temp0=%.1f\n", Temp0);
	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_set_sdd_trim_temp_exec(char *cmd)
{
	int ret, cnt;
	float Temp0;
	uint32_t Trim0;
	uint16_t Trim0_16;
	sdd_trim_temp_t param_sdd;

	struct sdd sdd;
	/* get param */
	cnt = cmd_sscanf(cmd, "%d %f", &Trim0, &Temp0);

	/* check param */
	if (cnt != 2) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}
	if (Trim0 > 127) {
		CMD_ERR("invalid value %d\n", Trim0);
		return CMD_STATUS_INVALID_ARG;
	}

	param_sdd.Temp0 = (uint32_t)(Temp0 * 10);

	ret = sdd_request(&sdd);
	if (ret == 0) {
		CMD_ERR("sdd not found!\n");
		return CMD_STATUS_ACKED;
	}
	Trim0_16 = (uint16_t)Trim0;
	if (sdd_set_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID, SDD_XTAL_TRIM_ELT_ID, (uint8_t *)&Trim0_16)) {
		CMD_ERR("fail to set ie %d\n", SDD_XTAL_TRIM_ELT_ID);
		return CMD_STATUS_ACKED;
	}
	if (sdd_set_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID, SDD_XTAL_TRIM_TEMPERATURE_ELT_ID, (uint8_t *)&(param_sdd.reserve))) {
		CMD_ERR("fail to set ie %d\n", SDD_XTAL_TRIM_TEMPERATURE_ELT_ID);
		return CMD_STATUS_ACKED;
	}
	if (sdd_save(&sdd)) {
		CMD_ERR("fail to save sdd to flash\n");
		return CMD_STATUS_ACKED;
	}
	CMD_LOG(1, "trim0=%d, temp0=%.1f\n", Trim0, Temp0);

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_get_sdd_trim_temp_exec(char *cmd)
{
	int ret;
	sdd_trim_temp_t param_sdd;
	uint16_t value;
	struct sdd sdd;

	ret = sdd_request(&sdd);
	if (ret > 0) {
		struct sdd_ie *ie = sdd_get_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID,
		                               SDD_XTAL_TRIM_TEMPERATURE_ELT_ID);
		memcpy(&(param_sdd.reserve), ie->data, ie->length);
		CMD_LOG(1, "length is :%d\n", ie->length);
		ie = sdd_get_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID,
		                SDD_XTAL_TRIM_ELT_ID);
		value = le16dec(ie->data);
		sdd_release(&sdd);
	} else {
		CMD_ERR("sdd not found!\n");
		return CMD_STATUS_ACKED;
	}

	CMD_LOG(1, "trim0=%d, temp0=%.1f\n", value, ((float)param_sdd.Temp0 / 10));

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_get_xtal_cal_exec(char *cmd)
{
	int ret;
	uint32_t cali_trim;

	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_GET_XTAL_CAL,
	                       (uint32_t)&cali_trim);

	if (ret == -2) {
		CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	} else if (ret == -1) {
		CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd);
		return CMD_STATUS_ACKED;
	}

	CMD_LOG(1, "new freq trim=%d\n", cali_trim);

	return CMD_STATUS_OK;
}

static OS_Timer_t g_auto_xtal_cal_timer;
static void auto_xtal_cal_timer_callback(void *arg)
{
	int ret;
	uint32_t cali_trim;

	ret = wlan_ext_request(wlan_netif_get(WLAN_MODE_NONE),
	                       WLAN_EXT_CMD_GET_XTAL_CAL,
	                       (uint32_t)&cali_trim);
	if (ret) {
		CMD_ERR("Get freq trim cali error!\n");
		return;
	}
	CMD_LOG(1, "new freq trim=%d\n", cali_trim);
	HAL_PRCM_SetDcxoFreqTrim(cali_trim);
	CMD_LOG(1, "Set freq trim to system\n");
}

enum cmd_status cmd_rf_set_auto_xtal_cal_exec(char *cmd)
{
	int cnt;
	uint32_t period;
	/* get param */
	cnt = cmd_sscanf(cmd, "%d", &period);
	/* check param */
	if (cnt != 1) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}

	if (period == 0) {
		if (OS_TimerIsValid(&g_auto_xtal_cal_timer)) {
			OS_TimerStop(&g_auto_xtal_cal_timer);
			OS_TimerDelete(&g_auto_xtal_cal_timer);
			CMD_LOG(1, "Stoped XTAL TRIM calib timer!\n");
		}
		return CMD_STATUS_OK;
	}

	if (OS_TimerIsActive(&g_auto_xtal_cal_timer)){
		OS_TimerChangePeriod(&g_auto_xtal_cal_timer, period);
	} else {
		OS_TimerSetInvalid(&g_auto_xtal_cal_timer);
		if (OS_TimerCreate(&g_auto_xtal_cal_timer, OS_TIMER_PERIODIC,
		                   auto_xtal_cal_timer_callback,
		                   NULL, period) != OS_OK) {
			CMD_ERR("timer create failed\n");
			return -1;
		}
		OS_TimerStart(&g_auto_xtal_cal_timer);
	}

	return CMD_STATUS_OK;
}

#endif

enum cmd_status cmd_rf_set_sdd_freq_offset_exec(char *cmd)
{
	int ret, cnt;
	uint32_t value;
	uint16_t value16;
	struct sdd sdd;
	/* get param */
	cnt = cmd_sscanf(cmd, "%d", &value);

	/* check param */
	if (cnt != 1) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}
	if (value > 127) {
		CMD_ERR("invalid value %d\n", value);
		return CMD_STATUS_INVALID_ARG;
	}

	value16 = (uint16_t)value;
	ret = sdd_request(&sdd);
	if (ret == 0) {
		CMD_ERR("sdd not found!\n");
		return CMD_STATUS_ACKED;
	}
	if (sdd_set_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID, SDD_XTAL_TRIM_ELT_ID, (uint8_t *)&value16)) {
		CMD_ERR("fail to set ie %d\n", SDD_XTAL_TRIM_ELT_ID);
		return CMD_STATUS_ACKED;
	}
	if (sdd_save(&sdd)) {
		CMD_ERR("fail to save sdd to flash\n");
		return CMD_STATUS_ACKED;
	}
	CMD_LOG(1, "sdd freq offset is set to %d!\n", value);

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_get_sdd_freq_offset_exec(char *cmd)
{
	int ret;
	uint16_t value;
	struct sdd sdd;

	ret = sdd_request(&sdd);
	if (ret > 0) {
		struct sdd_ie *id = sdd_get_ie(&sdd, SDD_WLAN_DYNAMIC_SECT_ID,
		                               SDD_XTAL_TRIM_ELT_ID);
		value = le16dec(id->data);
		sdd_release(&sdd);
	} else {
		CMD_ERR("sdd not found!\n");
		return CMD_STATUS_ACKED;
	}

	CMD_LOG(1, "sdd freq offset is :%d\n", value);
	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_set_freq_offset_exec(char *cmd)
{
	int cnt;
	uint32_t value;
	/* get param */
	cnt = cmd_sscanf(cmd, "%d", &value);

	/* check param */
	if (cnt != 1) {
		CMD_ERR("invalid param number %d\n", cnt);
		return CMD_STATUS_INVALID_ARG;
	}
	if (value > 127) {
		CMD_ERR("invalid value %d\n", value);
		return CMD_STATUS_INVALID_ARG;
	}

	HAL_PRCM_SetDcxoFreqTrim(value);
	CMD_LOG(1, "freq offset is set to %d!\n", value);

	return CMD_STATUS_OK;
}

enum cmd_status cmd_rf_get_freq_offset_exec(char *cmd)
{
	CMD_LOG(1, "freq offset is :%d\n",
	        (PRCM->DCXO_CTRL & PRCM_FREQ_OFFSET_MASK) >> PRCM_FREQ_OFFSET_SHIFT);
	return CMD_STATUS_OK;
}

/*
 * rf commands
 */
static enum cmd_status cmd_rf_help_exec(char *cmd);

static const struct cmd_data g_rf_cmds[] = {
#if PRJCONF_NET_EN
	{ "set_sdd_power",        cmd_rf_set_sdd_power_exec, CMD_DESC("set the transmit power in sdd") },
	{ "get_sdd_power",        cmd_rf_get_sdd_power_exec, CMD_DESC("get the transmit power in sdd") },
	{ "set_power",            cmd_rf_set_power_exec,     CMD_DESC("set the transmit power") },
	{ "get_power",            cmd_rf_get_power_exec,     CMD_DESC("get the transmit power") },
	{ "get_sdd_file",         cmd_rf_get_sdd_file_exec,  CMD_DESC("get the sdd file") },
	{ "set_channel_fec",      cmd_rf_set_channel_fec,    CMD_DESC("set the channel fec") },
	{ "set_xtal_cal_params",      cmd_rf_set_xtal_cal_params_exec, CMD_DESC("set the frequency offset calib param") },
	{ "set_sdd_xtal_cal_params",  cmd_rf_set_sdd_xtal_cal_params_exec, CMD_DESC("set the frequency offset calib param in sdd") },
	{ "get_sdd_xtal_cal_params",  cmd_rf_get_sdd_xtal_cal_params_exec, CMD_DESC("get the frequency offset calib param in sdd") },
	{ "set_trim_temp",        cmd_rf_set_trim_temp_exec, CMD_DESC("set the frequency offset trim temperature") },
	{ "set_sdd_trim_temp",    cmd_rf_set_sdd_trim_temp_exec, CMD_DESC("set the frequency offset trim temp in sdd") },
	{ "get_sdd_trim_temp",    cmd_rf_get_sdd_trim_temp_exec, CMD_DESC("get the frequency offset trim temp in sdd") },
	{ "get_xtal_cal",         cmd_rf_get_xtal_cal_exec, CMD_DESC("get the frequency offset trim calib value") },
	{ "set_auto_xtal_cal",    cmd_rf_set_auto_xtal_cal_exec, CMD_DESC("auto get the frequency offset trim calib value and set it to system") },
	{ "help",                 cmd_rf_help_exec,          CMD_DESC(CMD_HELP_DESC) },
#endif
	{ "set_sdd_freq_offset",  cmd_rf_set_sdd_freq_offset_exec, CMD_DESC("set the frequency offset in sdd") },
	{ "get_sdd_freq_offset",  cmd_rf_get_sdd_freq_offset_exec, CMD_DESC("get the frequency offset in sdd") },
	{ "get_freq_offset",      cmd_rf_get_freq_offset_exec,     CMD_DESC("set the frequency offset") },
	{ "set_freq_offset",      cmd_rf_set_freq_offset_exec,     CMD_DESC("get the frequency offset") },
	{ "help",                 cmd_rf_help_exec,                CMD_DESC(CMD_HELP_DESC) },
};

static enum cmd_status cmd_rf_help_exec(char *cmd)
{
	return cmd_help_exec(g_rf_cmds, cmd_nitems(g_rf_cmds), 24);
}

enum cmd_status cmd_rf_exec(char *cmd)
{
	return cmd_exec(cmd, g_rf_cmds, cmd_nitems(g_rf_cmds));
}