/******************************************************************************
 *
 * Copyright(c) 2020 Realtek Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 *****************************************************************************/
#include "phl_headers.h"
#include "phl_chnlplan.h"
#include "phl_chnlplan_6g.h"
#include "phl_country.h"

extern const struct chdef_6ghz chdef6g[MAX_CHDEF_6GHZ];
extern const struct regulatory_domain_mapping_6g rdmap6[MAX_RD_MAP_NUM_6GHZ];

static void _get_6ghz_ch_info(const struct chdef_6ghz *chdef,
	u8 group, u32 *ch, u32 *passive, u8 *max_num, u8 *ch_start)
{
	switch (group) {
	case FREQ_GROUP_6GHZ_UNII5:
		*ch = ((chdef->support_ch_u5[2] << 16) |
			(chdef->support_ch_u5[1] << 8) |
			(chdef->support_ch_u5[0]));
		*passive = ((chdef->passive_u5[2] << 16) |
			(chdef->passive_u5[1] << 8) |
			(chdef->passive_u5[0]));
		*max_num = MAX_CH_NUM_UNII5;
		*ch_start = 1;
		break;
	case FREQ_GROUP_6GHZ_UNII6:
		*ch = chdef->support_ch_u6;
		*passive = chdef->passive_u6;
		*max_num = MAX_CH_NUM_UNII6;
		*ch_start = 97;
		break;
	case FREQ_GROUP_6GHZ_UNII7:
		*ch = ((chdef->support_ch_u7[2] << 16) |
			(chdef->support_ch_u7[1] << 8) |
			(chdef->support_ch_u7[0]));
		*passive = ((chdef->passive_u7[2] << 16) |
			(chdef->passive_u7[1] << 8) |
			(chdef->passive_u7[0]));
		*max_num = MAX_CH_NUM_UNII7;
		*ch_start = 121;
		break;
	case FREQ_GROUP_6GHZ_UNII8:
		*ch = ((chdef->support_ch_u8[1] << 8) |
			(chdef->support_ch_u8[0]));
		*passive = ((chdef->passive_u8[1] << 8) |
			(chdef->passive_u8[0]));
		*max_num = MAX_CH_NUM_UNII8;
		*ch_start = 193;
		break;
	default:
		*ch = 0;
		*passive = 0;
		*max_num = 0;
		*ch_start = 0;
		break;
	}
}

static void _convert_ch6g(u8 unii_6g, struct rtw_regulation *rg,
			u32 *ch_cnt, struct rtw_regulation_channel *rch,
			u32 ch, u32 passive, u8 max_num, u8 ch_start)
{
	u16 i = 0;
	u32 shift = 0;
	u8 property = 0;
	u32 cnt = 0;

	PHL_INFO("[REGU], convert 6 ghz unii-%d channels, from %d, ch=0x%x, passive = 0x%x \n",
			unii_6g, ch_start, ch, passive);

	for (i = 0; i < max_num; i++) {
		shift = (1 << i);
		if (ch & shift) {
			property = 0;
			rch[*ch_cnt].band = BAND_ON_6G;
			rch[*ch_cnt].channel = (u8)(ch_start + (i * 4));

			if (passive & shift)
				property |= CH_PASSIVE;
			if ((rch[*ch_cnt].channel % 16) == 5)
				property |= CH_PSC;

			rch[*ch_cnt].property = property;
			PHL_INFO("[REGU], ch: %d%s%s \n",
				rch[*ch_cnt].channel,
				((property & CH_PASSIVE) ? ", passive" : ""),
				((property & CH_PSC) ? ", psc" : ""));
			(*ch_cnt)++;
			cnt++;
		}
	}

	PHL_INFO("[REGU], converted channels : %d\n", cnt);
}

static void _update_psc_group(struct rtw_regulation *rg)
{
	u8 group = FREQ_GROUP_6GHZ_UNII5;
	struct rtw_regulation_chplan_group *plan =
		&rg->chplan[FREQ_GROUP_6GHZ_PSC];
	struct rtw_regulation_chplan_group *src = NULL;
	u32 i = 0, j = 0;

	plan->cnt = 0;
	for (i = 0; i < 4; i++) {
		group = (u8)(i + FREQ_GROUP_6GHZ_UNII5);
		src = &rg->chplan[group];

		for (j = 0; j < src->cnt; j++) {
			if (src->ch[j].property & CH_PSC) {
				plan->ch[plan->cnt].band =
					src->ch[j].band;
				plan->ch[plan->cnt].channel =
					src->ch[j].channel;
				plan->ch[plan->cnt].property =
					src->ch[j].property;
				plan->cnt++;
			}
		}
	}
}

static bool _chnlplan_update_6g(struct rtw_regulation *rg,
			u8 regulation, u8 ch_idx)
{
	const struct chdef_6ghz *chdef = NULL;
	struct rtw_regulation_chplan_group *plan = NULL;
	u8 group = FREQ_GROUP_6GHZ_UNII5;
	u8 max_num = 0, ch_start = 0;
	u16 i = 0;
	u32 ch = 0, passive = 0;
	u32 total = 0;

	if (regulation >= REGULATION_MAX)
		return false;

	for (i = 0; i < MAX_CHDEF_6GHZ; i++) {
		if (ch_idx == chdef6g[i].idx) {
			chdef = &chdef6g[i];
			break;
		}
	}

	if (!chdef)
		return false;

	rg->ch_idx6g = ch_idx;
	rg->regulation_6g = regulation;

	for (i = 0; i < 4; i++) {
		group = (u8)(i + FREQ_GROUP_6GHZ_UNII5);
		plan = &rg->chplan[group];
		plan->cnt = 0;
		_get_6ghz_ch_info(chdef, group,
			&ch, &passive, &max_num, &ch_start);
		_convert_ch6g((u8)(i + 5), rg, &plan->cnt, plan->ch,
			ch, passive, max_num, ch_start);
		total += plan->cnt;
	}

	_update_psc_group(rg);

	PHL_INFO("[REGU], 6 GHz, total channel = %d\n", total);

	return true;
}

static u8 _domain_index_6g(u16 domain)
{
	u8 i = 0;

	for (i = 0; i < MAX_RD_MAP_NUM_6GHZ; i++) {
		if (domain == rdmap6[i].domain_code) {
			return i;
		}
	}

	return MAX_RD_MAP_NUM_6GHZ;
}

static bool _regulatory_domain_update_6g(struct rtw_regulation *rg,
			u16 domain, enum regulation_rsn reason)
{
	u8 regulation = REGULATION_NA;
	u8 ch_idx = 0, did = 0;

	rg->domain_6g.reason = reason;
	if (domain == RSVD_DOMAIN) {
		rg->domain_6g.code = RSVD_DOMAIN;
		return true;
	} else {
		/* Note: only valid domain index can reach here */
		did = _domain_index_6g(domain);
		rg->domain_6g.code = rdmap6[did].domain_code;
		regulation = rdmap6[did].regulation;
		ch_idx = rdmap6[did].ch_idx;
		return _chnlplan_update_6g(rg, regulation, ch_idx);
	}
}

static void _get_group_chplan_6g(struct rtw_regulation *rg,
			struct rtw_regulation_chplan_group *group,
			struct rtw_regulation_chplan *plan)
{
	u32 i = 0;

	for (i = 0; i < group->cnt; i++) {
		if (group->ch[i].channel) {
			plan->ch[plan->cnt].band =
				group->ch[i].band;
			plan->ch[plan->cnt].channel =
				group->ch[i].channel;
			plan->ch[plan->cnt].property =
				group->ch[i].property;
			plan->cnt++;
		}
	}
}

static void _history_log_6g(struct rtw_regulation *rg, u16 domain, u8 reason)
{
	rg->history_6g[rg->history_cnt_6g].code = domain;
	rg->history_6g[rg->history_cnt_6g].reason = reason;
	rg->history_cnt_6g++;
	if (rg->history_cnt_6g >= MAX_HISTORY_NUM)
		rg->history_cnt_6g = 0;
}

void regu_get_chnlplan_6g(struct rtw_regulation *rg,
				enum rtw_regulation_query type,
				struct rtw_regulation_chplan *plan)
{
	struct rtw_regulation_chplan_group *group = NULL;

	/* 6ghz */
	if (rg->capability & CAPABILITY_6GHZ) {
		/* unii5 */
		if (type == REGULQ_CHPLAN_6GHZ ||
			type == REGULQ_CHPLAN_6GHZ_UNII5) {
			group = &rg->chplan[FREQ_GROUP_6GHZ_UNII5];
			_get_group_chplan_6g(rg, group, plan);
		}
		/* unii6 */
		if (type == REGULQ_CHPLAN_6GHZ ||
			type == REGULQ_CHPLAN_6GHZ_UNII6) {
			group = &rg->chplan[FREQ_GROUP_6GHZ_UNII6];
			_get_group_chplan_6g(rg, group, plan);
		}
		/* unii7 */
		if (type == REGULQ_CHPLAN_6GHZ ||
			type == REGULQ_CHPLAN_6GHZ_UNII7) {
			group = &rg->chplan[FREQ_GROUP_6GHZ_UNII7];
			_get_group_chplan_6g(rg, group, plan);
		}
		/* unii8 */
		if (type == REGULQ_CHPLAN_6GHZ ||
			type == REGULQ_CHPLAN_6GHZ_UNII8) {
			group = &rg->chplan[FREQ_GROUP_6GHZ_UNII8];
			_get_group_chplan_6g(rg, group, plan);
		}
		/* psc */
		if (type == REGULQ_CHPLAN_FULL ||
			type == REGULQ_CHPLAN_6GHZ_PSC) {
			group = &rg->chplan[FREQ_GROUP_6GHZ_PSC];
			_get_group_chplan_6g(rg, group, plan);
		}
	}
}

bool regu_valid_domain_6g(u16 domain)
{
	if (domain == RSVD_DOMAIN)
		return true;

	if (_domain_index_6g(domain) >= MAX_RD_MAP_NUM_6GHZ)
		return false;

	return true;
}

bool regu_set_domain_6g(void *phl, u16 domain,
				       	enum regulation_rsn reason)
{
	struct phl_info_t *phl_info = (struct phl_info_t *)phl;
	struct rtw_regulation *rg = NULL;
	void *d = NULL;

	PHL_INFO("[REGU], set 6 ghz domain code = 0x%x, reason = 0x%x\n",
			domain, reason);

	if (!phl_info)
		return false;

	rg = &phl_info->regulation;
	if (!rg->init)
		return false;

	if (!regu_valid_domain_6g(domain))
		return false;

	d = phl_to_drvpriv(phl_info);

	_os_spinlock(d, &rg->lock, _bh, NULL);

	_history_log_6g(rg, domain, reason);

	if (_regulatory_domain_update_6g(rg, domain, reason))
		rg->valid_6g = true;
	else {
		rg->valid_6g = false;
		rg->invalid_cnt_6g++;
	}
	_os_spinunlock(d, &rg->lock, _bh, NULL);

	PHL_INFO("[REGU], 6 ghz domain code valid = %d\n", rg->valid_6g);

	return rg->valid_6g;
}