/*
|
* 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 */
|
};
|
