/*
 * Common [OS-independent] rate management
 * 802.11 Networking Adapter Device Driver.
 *
 * Broadcom Proprietary and Confidential. Copyright (C) 2020,
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom;
 * the contents of this file may not be disclosed to third parties,
 * copied or duplicated in any form, in whole or in part, without
 * the prior written permission of Broadcom.
 *
 *
 * <<Broadcom-WL-IPTag/Proprietary:>>
 */

#include <typedefs.h>
#ifdef BCMDRIVER
#include <osl.h>
#else
#include <assert.h>
#ifndef ASSERT
#define ASSERT(e)	assert(e)
#endif
#ifndef ASSERT_FP
#define ASSERT_FP(e)	assert(e)
#endif
#endif /* BCMDRIVER */
#include <802.11.h>
#include <802.11ax.h>
#include <bcmutils.h>

#include <bcmwifi_rspec.h>
#include <bcmwifi_rates.h>

/* TODO: Consolidate rate utility functions from wlc_rate.c and bcmwifi_monitor.c
 * into here if they're shared by non wl layer as well...
 */

/* ============================================ */
/* Moved from wlc_rate.c                        */
/* ============================================ */

/* HE mcs info */
struct ieee_80211_mcs_rate_info {
	uint8 constellation_bits;
	uint8 coding_q;
	uint8 coding_d;
	uint8 dcm_capable;	/* 1 if dcm capable */
};

static const struct ieee_80211_mcs_rate_info wlc_mcs_info[] = {
	{ 1, 1, 2, 1 }, /* MCS  0: MOD: BPSK,   CR 1/2, dcm capable */
	{ 2, 1, 2, 1 }, /* MCS  1: MOD: QPSK,   CR 1/2, dcm capable */
	{ 2, 3, 4, 0 }, /* MCS  2: MOD: QPSK,   CR 3/4, NOT dcm capable */
	{ 4, 1, 2, 1 }, /* MCS  3: MOD: 16QAM,  CR 1/2, dcm capable */
	{ 4, 3, 4, 1 }, /* MCS  4: MOD: 16QAM,  CR 3/4, dcm capable */
	{ 6, 2, 3, 0 }, /* MCS  5: MOD: 64QAM,  CR 2/3, NOT dcm capable */
	{ 6, 3, 4, 0 }, /* MCS  6: MOD: 64QAM,  CR 3/4, NOT dcm capable */
	{ 6, 5, 6, 0 }, /* MCS  7: MOD: 64QAM,  CR 5/6, NOT dcm capable */
	{ 8, 3, 4, 0 }, /* MCS  8: MOD: 256QAM, CR 3/4, NOT dcm capable */
	{ 8, 5, 6, 0 }, /* MCS  9: MOD: 256QAM, CR 5/6, NOT dcm capable */
	{ 10, 3, 4, 0 }, /* MCS 10: MOD: 1024QAM, CR 3/4, NOT dcm capable */
	{ 10, 5, 6, 0 }, /* MCS 11: MOD: 1024QAM, CR 5/6, NOT dcm capable */
#ifdef WL11BE
	/* TODO: for now EHT shares this table with HE,
	 * create a new table if needed once we know more
	 * about EHT rate calculation...
	 */
	{ 12, 3, 4, 0 }, /* MCS 12: MOD: 4096QAM, CR 3/4, NOT dcm capable */
	{ 12, 5, 6, 0 }, /* MCS 13: MOD: 4096QAM, CR 5/6, NOT dcm capable */
#endif
};

/* Nsd values Draft0.4 Table 26.63 onwards */
static const uint wlc_he_nsd[] = {
	234,	/* BW20 */
	468,	/* BW40 */
	980,	/* BW80 */
	1960,	/* BW160 */
#ifdef WL11BE
	/* TODO: for now EHT shares this table with HE,
	 * create a new table if needed once we know more
	 * about EHT rate calculation...
	 */
	2940,	/* BW240 */
	3920	/* BW320 */
#endif
};

/* Nsd values Draft3.3 Table 28-15 */
static const uint wlc_he_ru_nsd[] = {
	24,	/* 26T */
	48,	/* 52T */
	102,	/* 106T */
	234,	/* 242T/BW20 */
	468,	/* 484T/BW40 */
	980,	/* 996T/BW80 */
	1960,	/* 2*996T/BW160 */
#ifdef WL11BE
	/* TODO: for now EHT shares this table with HE,
	 * create a new table if needed once we know more
	 * about EHT rate calculation...
	 */
	2940,	/* 3*996T/BW240 */
	3920	/* 4*996T/BW320 */
#endif
};

#define HE_RU_TO_NSD(ru_idx)	\
	(ru_idx < ARRAYSIZE(wlc_he_ru_nsd)) ? \
	wlc_he_ru_nsd[ru_idx] : 0

/* sym_len = 12.8 us. For calculation purpose, *10 */
#define HE_SYM_LEN_FACTOR		(128)

/* GI values = 0.8 , 1.6 or 3.2 us. For calculation purpose, *10 */
#define HE_GI_800us_FACTOR		(8)
#define HE_GI_1600us_FACTOR		(16)
#define HE_GI_3200us_FACTOR		(32)

/* To avoid ROM invalidation use the old macro as is... */
#ifdef WL11BE
#define HE_BW_TO_NSD(bwi) \
	((bwi) > 0u && (bwi) <= ARRAYSIZE(wlc_he_nsd)) ? \
	wlc_he_nsd[(bwi) - 1u] : 0u
#else
#define HE_BW_TO_NSD(bwi) \
	((bwi) > 0 && ((bwi) << WL_RSPEC_BW_SHIFT) <= WL_RSPEC_BW_160MHZ) ? \
	wlc_he_nsd[(bwi)-1] : 0
#endif /* WL11BE */

#define ksps		250 /* kilo symbols per sec, 4 us sym */

#ifdef WL11BE
/* Table "wlc_nsd" is derived from HT and VHT #defines below, but extended for HE
 * for rate calculation purpose at a given NSS and bandwidth combination.
 *
 * It should and can only be used in where it wants to know the relative rate in kbps
 * for a different NSS and bandwidth combination at a given mcs e.g. in fallback rate
 * search. It shouldn not and can not be used in where it calculates the absolute rate
 * i.e. the result doesn't agree with what the spec says otherwise.
 *
 * See Std 802.11-2016 "Table 21-61 VHT-MCSs for optional 160 MHz and 80+80 MHz, NSS = 8"
 * for VHT, and P802.11ax/D6.0 "Table 27-111 HE-MCSs for 2x996-tone RU, NSS = 8" for HE,
 * for 160Mhz bandwidth for resulting rate comparison.
 *
 * It's again extended for EHT 240/320Mhz bandwidth, for the same purpose.
 */
static const uint16 wlc_nsd[] = {
	52,	/* 20MHz */
	108,	/* 40MHz */
	234,	/* 80Mhz */
	468,	/* 160MHz */
	702,	/* 240MHz */
	936,	/* 320MHz */
};

#define BW_TO_NSD(bwi) \
	((bwi) > 0u && (bwi) <= ARRAYSIZE(wlc_nsd)) ? \
	wlc_nsd[(bwi) - 1u] : 0u

static uint
wf_nsd2ndbps(uint mcs, uint nss, uint nsd, bool dcm)
{
	uint Ndbps;

	/* multiply number of spatial streams,
	 * bits per number from the constellation,
	 * and coding quotient
	 */
	Ndbps = nsd * nss *
		wlc_mcs_info[mcs].coding_q * wlc_mcs_info[mcs].constellation_bits;

	/* adjust for the coding rate divisor */
	Ndbps = Ndbps / wlc_mcs_info[mcs].coding_d;

	/* take care of dcm: dcm divides R by 2. If not dcm mcs, ignore */
	if (dcm) {
		if (wlc_mcs_info[mcs].dcm_capable) {
			Ndbps >>= 1u;
		}
	}

	return Ndbps;
}
#else
/* for HT and VHT? */
#define Nsd_20MHz	52
#define Nsd_40MHz	108
#define Nsd_80MHz	234
#define Nsd_160MHz	468
#endif /* WL11BE */

uint
wf_he_mcs_to_Ndbps(uint mcs, uint nss, uint bw, bool dcm)
{
	uint Nsd;
	uint Ndbps;

	/* find the number of complex numbers per symbol */
	Nsd = HE_BW_TO_NSD(bw >> WL_RSPEC_BW_SHIFT);

#ifdef WL11BE
	Ndbps = wf_nsd2ndbps(mcs, nss, Nsd, dcm);
#else
	/* multiply number of spatial streams,
	 * bits per number from the constellation,
	 * and coding quotient
	 */
	Ndbps = Nsd * nss *
		wlc_mcs_info[mcs].coding_q * wlc_mcs_info[mcs].constellation_bits;

	/* adjust for the coding rate divisor */
	Ndbps = Ndbps / wlc_mcs_info[mcs].coding_d;

	/* take care of dcm: dcm divides R by 2. If not dcm mcs, ignore */
	if (dcm) {
		if (wlc_mcs_info[mcs].dcm_capable) {
			Ndbps >>= 1;
		}
	}
#endif /* WL11BE */

	return Ndbps;
}

uint32
wf_he_mcs_ru_to_ndbps(uint8 mcs, uint8 nss, bool dcm, uint8 ru_index)
{
	uint32 nsd;
	uint32 ndbps;

	/* find the number of complex numbers per symbol */
	nsd = HE_RU_TO_NSD(ru_index);

#ifdef WL11BE
	ndbps = wf_nsd2ndbps(mcs, nss, nsd, dcm);
#else
	/* multiply number of spatial streams,
	 * bits per number from the constellation,
	 * and coding quotient
	 * Ndbps = Nss x Nsd x (Nbpscs x R) x (DCM/2)
	 */
	ndbps = nsd * nss *
		wlc_mcs_info[mcs].coding_q * wlc_mcs_info[mcs].constellation_bits;

	/* adjust for the coding rate divisor */
	ndbps = ndbps / wlc_mcs_info[mcs].coding_d;

	/* take care of dcm: dcm divides R by 2. If not dcm mcs, ignore */
	if (dcm && wlc_mcs_info[mcs].dcm_capable) {
		ndbps >>= 1;
	}
#endif /* WL11BE */
	return ndbps;
}

/**
 * Returns the rate in [Kbps] units for a caller supplied MCS/bandwidth/Nss/Sgi/dcm combination.
 *     'mcs' : a *single* spatial stream MCS (11ax)
 * formula as per http:
 *	WLAN&preview=/323036249/344457953/11ax_rate_table.xlsx
 * Symbol length = 12.8 usec [given as sym_len/10 below]
 * GI value = 0.8 or 1.6 or 3.2 usec [given as GI_value/10 below]
 * rate (Kbps) = (Nsd * Nbpscs * nss * (coding_q/coding_d) * 1000) / ((sym_len/10) + (GI_value/10))
 *	 Note that, for calculation purpose, following is used. [to be careful with overflows]
 * rate (Kbps) = (Nsd * Nbpscs * nss * (coding_q/coding_d) * 1000) / ((sym_len + GI_value) / 10)
 * rate (Kbps) = (Nsd * Nbpscs * nss * (coding_q/coding_d) * 1000) / (sym_len + GI_value) * 10
 */
uint
wf_he_mcs_to_rate(uint mcs, uint nss, uint bw, uint gi, bool dcm)
{
	uint rate;
	uint rate_deno;

	rate = HE_BW_TO_NSD(bw >> WL_RSPEC_BW_SHIFT);

#ifdef WL11BE
	rate = wf_nsd2ndbps(mcs, nss, rate, dcm);
#else
	/* Nbpscs: multiply by bits per number from the constellation in use */
	rate = rate * wlc_mcs_info[mcs].constellation_bits;

	/* Nss: adjust for the number of spatial streams */
	rate = rate * nss;

	/* R: adjust for the coding rate given as a quotient and divisor */
	rate = (rate * wlc_mcs_info[mcs].coding_q) / wlc_mcs_info[mcs].coding_d;

	/* take care of dcm: dcm divides R by 2. If not dcm mcs, ignore */
	if (dcm) {
		if (wlc_mcs_info[mcs].dcm_capable) {
			rate >>= 1;
		}
	}
#endif /* WL11BE */

	/* add sym len factor */
	rate_deno = HE_SYM_LEN_FACTOR;

	/* get GI for denominator */
	if (HE_IS_GI_3_2us(gi)) {
		rate_deno += HE_GI_3200us_FACTOR;
	} else if (HE_IS_GI_1_6us(gi)) {
		rate_deno += HE_GI_1600us_FACTOR;
	} else {
		/* assuming HE_GI_0_8us */
		rate_deno += HE_GI_800us_FACTOR;
	}

	/* as per above formula */
	rate *= 1000;	/* factor of 10. *100 to accommodate 2 places */
	rate /= rate_deno;
	rate *= 10; /* *100 was already done above. Splitting is done to avoid overflow. */

	return rate;
}

uint
wf_mcs_to_Ndbps(uint mcs, uint nss, uint bw)
{
	uint Nsd;
	uint Ndbps;

	/* This calculation works for 11n HT and 11ac VHT if the HT mcs values
	 * are decomposed into a base MCS = MCS % 8, and Nss = 1 + MCS / 8.
	 * That is, HT MCS 23 is a base MCS = 7, Nss = 3
	 */

	/* find the number of complex numbers per symbol */
#ifdef WL11BE
	Nsd = BW_TO_NSD(bw >> WL_RSPEC_BW_SHIFT);

	Ndbps = wf_nsd2ndbps(mcs, nss, Nsd, FALSE);
#else
	if (bw == WL_RSPEC_BW_20MHZ) {
		Nsd = Nsd_20MHz;
	} else if (bw == WL_RSPEC_BW_40MHZ) {
		Nsd = Nsd_40MHz;
	} else if (bw == WL_RSPEC_BW_80MHZ) {
		Nsd = Nsd_80MHz;
	} else if (bw == WL_RSPEC_BW_160MHZ) {
		Nsd = Nsd_160MHz;
	} else {
		Nsd = 0;
	}

	/* multiply number of spatial streams,
	 * bits per number from the constellation,
	 * and coding quotient
	 */
	Ndbps = Nsd * nss *
		wlc_mcs_info[mcs].coding_q * wlc_mcs_info[mcs].constellation_bits;

	/* adjust for the coding rate divisor */
	Ndbps = Ndbps / wlc_mcs_info[mcs].coding_d;
#endif /* WL11BE */

	return Ndbps;
}

/**
 * Returns the rate in [Kbps] units for a caller supplied MCS/bandwidth/Nss/Sgi combination.
 *     'mcs' : a *single* spatial stream MCS (11n or 11ac)
 */
uint
wf_mcs_to_rate(uint mcs, uint nss, uint bw, int sgi)
{
	uint rate;

	if (mcs == 32) {
		/* just return fixed values for mcs32 instead of trying to parametrize */
		rate = (sgi == 0) ? 6000 : 6778;
	} else {
		/* This calculation works for 11n HT, 11ac VHT and 11ax HE if the HT mcs values
		 * are decomposed into a base MCS = MCS % 8, and Nss = 1 + MCS / 8.
		 * That is, HT MCS 23 is a base MCS = 7, Nss = 3
		 */

#if defined(WLPROPRIETARY_11N_RATES)
		switch (mcs) {
		case 87:
			mcs = 8; /* MCS  8: MOD: 256QAM, CR 3/4 */
			break;
		case 88:
			mcs = 9; /* MCS  9: MOD: 256QAM, CR 5/6 */
			break;
		default:
			break;
		}
#endif /* WLPROPRIETARY_11N_RATES */

#ifdef WL11BE
		rate = wf_mcs_to_Ndbps(mcs, nss, bw);
#else
		/* find the number of complex numbers per symbol */
		if (RSPEC_IS20MHZ(bw)) {
			/* 4360 TODO: eliminate Phy const in rspec bw, then just compare
			 * as in 80 and 160 case below instead of RSPEC_IS20MHZ(bw)
			 */
			rate = Nsd_20MHz;
		} else if (RSPEC_IS40MHZ(bw)) {
			/* 4360 TODO: eliminate Phy const in rspec bw, then just compare
			 * as in 80 and 160 case below instead of RSPEC_IS40MHZ(bw)
			 */
			rate = Nsd_40MHz;
		} else if (bw == WL_RSPEC_BW_80MHZ) {
			rate = Nsd_80MHz;
		} else if (bw == WL_RSPEC_BW_160MHZ) {
			rate = Nsd_160MHz;
		} else {
			rate = 0;
		}

		/* multiply by bits per number from the constellation in use */
		rate = rate * wlc_mcs_info[mcs].constellation_bits;

		/* adjust for the number of spatial streams */
		rate = rate * nss;

		/* adjust for the coding rate given as a quotient and divisor */
		rate = (rate * wlc_mcs_info[mcs].coding_q) / wlc_mcs_info[mcs].coding_d;
#endif /* WL11BE */

		/* multiply by Kilo symbols per sec to get Kbps */
		rate = rate * ksps;

		/* adjust the symbols per sec for SGI
		 * symbol duration is 4 us without SGI, and 3.6 us with SGI,
		 * so ratio is 10 / 9
		 */
		if (sgi) {
			/* add 4 for rounding of division by 9 */
			rate = ((rate * 10) + 4) / 9;
		}
	}

	return rate;
} /* wf_mcs_to_rate */

/* This function needs update to handle MU frame PLCP as well (MCS is conveyed via VHT-SIGB
 * field in case of MU frames). Currently this support needs to be added in uCode to communicate
 * MCS information for an MU frame
 *
 *	For VHT frame:
 *		bit 0-3 mcs index
 *		bit 6-4 nsts for VHT
 *		bit 7:	 1 for VHT
 *	Note: bit 7 is used to indicate to the rate sel the mcs is a non HT mcs!
 *
 * Essentially it's the NSS:MCS portions of the rspec
 */
uint8
wf_vht_plcp_to_rate(uint8 *plcp)
{
	uint8 rate, gid;
	uint nss;
	uint32 plcp0 = plcp[0] + (plcp[1] << 8); /* don't need plcp[2] */

	gid = (plcp0 & VHT_SIGA1_GID_MASK) >> VHT_SIGA1_GID_SHIFT;
	if (gid > VHT_SIGA1_GID_TO_AP && gid < VHT_SIGA1_GID_NOT_TO_AP) {
		/* for MU packet we hacked Signal Tail field in VHT-SIG-A2 to save nss and mcs,
		 * copy from murate in d11 rx header.
		 * nss = bit 18:19 (for 11ac 2 bits to indicate maximum 4 nss)
		 * mcs = 20:23
		 */
		rate = (plcp[5] & 0xF0) >> 4;
		nss = ((plcp[5] & 0x0C) >> 2) + 1;
	} else {
		rate = (plcp[3] >> VHT_SIGA2_MCS_SHIFT);
		nss = ((plcp0 & VHT_SIGA1_NSTS_SHIFT_MASK_USER0) >>
			VHT_SIGA1_NSTS_SHIFT) + 1;
		if (plcp0 & VHT_SIGA1_STBC)
			nss = nss >> 1;
	}
	rate |= ((nss << WL_RSPEC_VHT_NSS_SHIFT) | WF_NON_HT_MCS);

	return rate;
}

/**
 * Function for computing NSS:MCS from HE SU PLCP or
 * MCS:LTF-GI from HE MU PLCP
 *
 * based on rev3.10 :
 * https://docs.google.com/spreadsheets/d/
 * 1eP6ZCRrtnF924ds1R-XmbcH0IdQ0WNJpS1-FHmWeb9g/edit#gid=1492656555
 *
 *	For HE SU frame:
 *		bit 0-3 mcs index
 *		bit 6-4 nsts for HE
 *		bit 7:	 1 for HE
 *	Note: bit 7 is used to indicate to the rate sel the mcs is a non HT mcs!
 *	Essentially it's the NSS:MCS portions of the rspec
 *
 *	For HE MU frame:
 *		bit 0-3 mcs index
 *		bit 4-5 LTF-GI value
 *		bit 6 STBC
 *	Essentially it's the MCS and LTF-GI portion of the rspec
 */
/* Macros to be used for calculating rate from PLCP */
#define HE_SU_PLCP2RATE_MCS_MASK	0x0F
#define HE_SU_PLCP2RATE_MCS_SHIFT	0
#define HE_SU_PLCP2RATE_NSS_MASK	0x70
#define HE_SU_PLCP2RATE_NSS_SHIFT	4
#define HE_MU_PLCP2RATE_LTF_GI_MASK	0x30
#define HE_MU_PLCP2RATE_LTF_GI_SHIFT	4
#define HE_MU_PLCP2RATE_STBC_MASK	0x40
#define HE_MU_PLCP2RATE_STBC_SHIFT	6

uint8
wf_he_plcp_to_rate(uint8 *plcp, bool is_mu)
{
	uint8 rate = 0;
	uint8 nss = 0;
	uint32 plcp0 = 0;
	uint32 plcp1 = 0;
	uint8 he_ltf_gi;
	uint8 stbc;

	ASSERT(plcp);

	BCM_REFERENCE(nss);
	BCM_REFERENCE(he_ltf_gi);

	plcp0 = ((plcp[3] << 24) | (plcp[2] << 16) | (plcp[1] << 8) | plcp[0]);
	plcp1 = ((plcp[5] << 8) | plcp[4]);

	if (!is_mu) {
		/* For SU frames return rate in MCS:NSS format */
		rate = ((plcp0 & HE_SU_RE_SIGA_MCS_MASK) >> HE_SU_RE_SIGA_MCS_SHIFT);
		nss = ((plcp0 & HE_SU_RE_SIGA_NSTS_MASK) >> HE_SU_RE_SIGA_NSTS_SHIFT) + 1;
		rate |= ((nss << HE_SU_PLCP2RATE_NSS_SHIFT) | WF_NON_HT_MCS);
	} else {
		/* For MU frames return rate in MCS:LTF-GI format */
		rate = (plcp0 & HE_MU_SIGA_SIGB_MCS_MASK) >> HE_MU_SIGA_SIGB_MCS_SHIFT;
		he_ltf_gi = (plcp0 & HE_MU_SIGA_GI_LTF_MASK) >> HE_MU_SIGA_GI_LTF_SHIFT;
		stbc = (plcp1 & HE_MU_SIGA_STBC_MASK) >> HE_MU_SIGA_STBC_SHIFT;

		/* LTF-GI shall take the same position as NSS */
		rate |= (he_ltf_gi << HE_MU_PLCP2RATE_LTF_GI_SHIFT);

		/* STBC needs to be filled in bit 6 */
		rate |= (stbc << HE_MU_PLCP2RATE_STBC_SHIFT);
	}

	return rate;
}

/**
 * Function for computing NSS:MCS from EHT SU PLCP or
 * MCS:LTF-GI from EHT MU PLCP
 *
 * TODO: add link to the HW spec.
 * FIXME: do we really need to support mu?
 */
uint8
wf_eht_plcp_to_rate(uint8 *plcp, bool is_mu)
{
	BCM_REFERENCE(plcp);
	BCM_REFERENCE(is_mu);
	ASSERT(!"wf_eht_plcp_to_rate: not implemented!");
	return 0;
}

/* ============================================ */
/* Moved from wlc_rate_def.c                    */
/* ============================================ */

/**
 * Some functions require a single stream MCS as an input parameter. Given an MCS, this function
 * returns the single spatial stream MCS equivalent.
 */
uint8
wf_get_single_stream_mcs(uint mcs)
{
	if (mcs < 32) {
		return mcs % 8;
	}
	switch (mcs) {
	case 32:
		return 32;
	case 87:
	case 99:
	case 101:
		return 87;	/* MCS 87: SS 1, MOD: 256QAM, CR 3/4 */
	default:
		return 88;	/* MCS 88: SS 1, MOD: 256QAM, CR 5/6 */
	}
}

/* ============================================ */
/* Moved from wlc_phy_iovar.c                   */
/* ============================================ */

const uint8 plcp_ofdm_rate_tbl[] = {
	DOT11_RATE_48M, /* 8: 48Mbps */
	DOT11_RATE_24M, /* 9: 24Mbps */
	DOT11_RATE_12M, /* A: 12Mbps */
	DOT11_RATE_6M,  /* B:  6Mbps */
	DOT11_RATE_54M, /* C: 54Mbps */
	DOT11_RATE_36M, /* D: 36Mbps */
	DOT11_RATE_18M, /* E: 18Mbps */
	DOT11_RATE_9M   /* F:  9Mbps */
};