// SPDX-License-Identifier: GPL-2.0
|
/******************************************************************************
|
*
|
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
|
*
|
******************************************************************************/
|
#define _HAL_COM_PHYCFG_C_
|
|
#include <drv_types.h>
|
#include <rtw_debug.h>
|
#include <hal_data.h>
|
#include <linux/kernel.h>
|
|
u8 PHY_GetTxPowerByRateBase(struct adapter *Adapter, u8 Band, u8 RfPath,
|
u8 TxNum, enum RATE_SECTION RateSection)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
u8 value = 0;
|
|
if (RfPath > ODM_RF_PATH_D) {
|
DBG_871X("Invalid Rf Path %d in PHY_GetTxPowerByRateBase()\n", RfPath);
|
return 0;
|
}
|
|
if (Band == BAND_ON_2_4G) {
|
switch (RateSection) {
|
case CCK:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][0];
|
break;
|
case OFDM:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][1];
|
break;
|
case HT_MCS0_MCS7:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][2];
|
break;
|
case HT_MCS8_MCS15:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][3];
|
break;
|
case HT_MCS16_MCS23:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][4];
|
break;
|
case HT_MCS24_MCS31:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][5];
|
break;
|
case VHT_1SSMCS0_1SSMCS9:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][6];
|
break;
|
case VHT_2SSMCS0_2SSMCS9:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][7];
|
break;
|
case VHT_3SSMCS0_3SSMCS9:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][8];
|
break;
|
case VHT_4SSMCS0_4SSMCS9:
|
value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][9];
|
break;
|
default:
|
DBG_871X("Invalid RateSection %d in Band 2.4G, Rf Path %d, %dTx in PHY_GetTxPowerByRateBase()\n",
|
RateSection, RfPath, TxNum);
|
break;
|
}
|
} else if (Band == BAND_ON_5G) {
|
switch (RateSection) {
|
case OFDM:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][0];
|
break;
|
case HT_MCS0_MCS7:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][1];
|
break;
|
case HT_MCS8_MCS15:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][2];
|
break;
|
case HT_MCS16_MCS23:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][3];
|
break;
|
case HT_MCS24_MCS31:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][4];
|
break;
|
case VHT_1SSMCS0_1SSMCS9:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][5];
|
break;
|
case VHT_2SSMCS0_2SSMCS9:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][6];
|
break;
|
case VHT_3SSMCS0_3SSMCS9:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][7];
|
break;
|
case VHT_4SSMCS0_4SSMCS9:
|
value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][8];
|
break;
|
default:
|
DBG_871X("Invalid RateSection %d in Band 5G, Rf Path %d, %dTx in PHY_GetTxPowerByRateBase()\n",
|
RateSection, RfPath, TxNum);
|
break;
|
}
|
} else
|
DBG_871X("Invalid Band %d in PHY_GetTxPowerByRateBase()\n", Band);
|
|
return value;
|
}
|
|
static void
|
phy_SetTxPowerByRateBase(
|
struct adapter *Adapter,
|
u8 Band,
|
u8 RfPath,
|
enum RATE_SECTION RateSection,
|
u8 TxNum,
|
u8 Value
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
|
if (RfPath > ODM_RF_PATH_D) {
|
DBG_871X("Invalid Rf Path %d in phy_SetTxPowerByRatBase()\n", RfPath);
|
return;
|
}
|
|
if (Band == BAND_ON_2_4G) {
|
switch (RateSection) {
|
case CCK:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][0] = Value;
|
break;
|
case OFDM:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][1] = Value;
|
break;
|
case HT_MCS0_MCS7:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][2] = Value;
|
break;
|
case HT_MCS8_MCS15:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][3] = Value;
|
break;
|
case HT_MCS16_MCS23:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][4] = Value;
|
break;
|
case HT_MCS24_MCS31:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][5] = Value;
|
break;
|
case VHT_1SSMCS0_1SSMCS9:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][6] = Value;
|
break;
|
case VHT_2SSMCS0_2SSMCS9:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][7] = Value;
|
break;
|
case VHT_3SSMCS0_3SSMCS9:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][8] = Value;
|
break;
|
case VHT_4SSMCS0_4SSMCS9:
|
pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][9] = Value;
|
break;
|
default:
|
DBG_871X("Invalid RateSection %d in Band 2.4G, Rf Path %d, %dTx in phy_SetTxPowerByRateBase()\n",
|
RateSection, RfPath, TxNum);
|
break;
|
}
|
} else if (Band == BAND_ON_5G) {
|
switch (RateSection) {
|
case OFDM:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][0] = Value;
|
break;
|
case HT_MCS0_MCS7:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][1] = Value;
|
break;
|
case HT_MCS8_MCS15:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][2] = Value;
|
break;
|
case HT_MCS16_MCS23:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][3] = Value;
|
break;
|
case HT_MCS24_MCS31:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][4] = Value;
|
break;
|
case VHT_1SSMCS0_1SSMCS9:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][5] = Value;
|
break;
|
case VHT_2SSMCS0_2SSMCS9:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][6] = Value;
|
break;
|
case VHT_3SSMCS0_3SSMCS9:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][7] = Value;
|
break;
|
case VHT_4SSMCS0_4SSMCS9:
|
pHalData->TxPwrByRateBase5G[RfPath][TxNum][8] = Value;
|
break;
|
default:
|
DBG_871X("Invalid RateSection %d in Band 5G, Rf Path %d, %dTx in phy_SetTxPowerByRateBase()\n",
|
RateSection, RfPath, TxNum);
|
break;
|
}
|
} else
|
DBG_871X("Invalid Band %d in phy_SetTxPowerByRateBase()\n", Band);
|
}
|
|
static void
|
phy_StoreTxPowerByRateBase(
|
struct adapter *padapter
|
)
|
{
|
u8 path, base;
|
|
/* DBG_871X("===>%s\n", __func__); */
|
|
for (path = ODM_RF_PATH_A; path <= ODM_RF_PATH_B; ++path) {
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_11M);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, CCK, RF_1TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 1Tx CCK = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_54M);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, OFDM, RF_1TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 1Tx OFDM = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, HT_MCS0_MCS7, RF_1TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 1Tx MCS0-7 = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_2TX, MGN_MCS15);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, HT_MCS8_MCS15, RF_2TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 2Tx MCS8-15 = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_3TX, MGN_MCS23);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, HT_MCS16_MCS23, RF_3TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 3Tx MCS16-23 = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_VHT1SS_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, VHT_1SSMCS0_1SSMCS9, RF_1TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 1Tx VHT1SS = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_2TX, MGN_VHT2SS_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, VHT_2SSMCS0_2SSMCS9, RF_2TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 2Tx VHT2SS = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_3TX, MGN_VHT3SS_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, VHT_3SSMCS0_3SSMCS9, RF_3TX, base);
|
/* DBG_871X("Power index base of 2.4G path %d 3Tx VHT3SS = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_1TX, MGN_54M);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, OFDM, RF_1TX, base);
|
/* DBG_871X("Power index base of 5G path %d 1Tx OFDM = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_1TX, MGN_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, HT_MCS0_MCS7, RF_1TX, base);
|
/* DBG_871X("Power index base of 5G path %d 1Tx MCS0~7 = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_2TX, MGN_MCS15);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, HT_MCS8_MCS15, RF_2TX, base);
|
/* DBG_871X("Power index base of 5G path %d 2Tx MCS8~15 = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_3TX, MGN_MCS23);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, HT_MCS16_MCS23, RF_3TX, base);
|
/* DBG_871X("Power index base of 5G path %d 3Tx MCS16~23 = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_1TX, MGN_VHT1SS_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, VHT_1SSMCS0_1SSMCS9, RF_1TX, base);
|
/* DBG_871X("Power index base of 5G path %d 1Tx VHT1SS = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_2TX, MGN_VHT2SS_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, VHT_2SSMCS0_2SSMCS9, RF_2TX, base);
|
/* DBG_871X("Power index base of 5G path %d 2Tx VHT2SS = > 0x%x\n", path, base); */
|
|
base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_3TX, MGN_VHT2SS_MCS7);
|
phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, VHT_3SSMCS0_3SSMCS9, RF_3TX, base);
|
/* DBG_871X("Power index base of 5G path %d 3Tx VHT3SS = > 0x%x\n", path, base); */
|
}
|
|
/* DBG_871X("<===%s\n", __func__); */
|
}
|
|
u8 PHY_GetRateSectionIndexOfTxPowerByRate(
|
struct adapter *padapter, u32 RegAddr, u32 BitMask
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
|
u8 index = 0;
|
|
if (pDM_Odm->PhyRegPgVersion == 0) {
|
switch (RegAddr) {
|
case rTxAGC_A_Rate18_06:
|
index = 0;
|
break;
|
case rTxAGC_A_Rate54_24:
|
index = 1;
|
break;
|
case rTxAGC_A_CCK1_Mcs32:
|
index = 6;
|
break;
|
case rTxAGC_B_CCK11_A_CCK2_11:
|
if (BitMask == bMaskH3Bytes)
|
index = 7;
|
else if (BitMask == 0x000000ff)
|
index = 15;
|
break;
|
|
case rTxAGC_A_Mcs03_Mcs00:
|
index = 2;
|
break;
|
case rTxAGC_A_Mcs07_Mcs04:
|
index = 3;
|
break;
|
case rTxAGC_A_Mcs11_Mcs08:
|
index = 4;
|
break;
|
case rTxAGC_A_Mcs15_Mcs12:
|
index = 5;
|
break;
|
case rTxAGC_B_Rate18_06:
|
index = 8;
|
break;
|
case rTxAGC_B_Rate54_24:
|
index = 9;
|
break;
|
case rTxAGC_B_CCK1_55_Mcs32:
|
index = 14;
|
break;
|
case rTxAGC_B_Mcs03_Mcs00:
|
index = 10;
|
break;
|
case rTxAGC_B_Mcs07_Mcs04:
|
index = 11;
|
break;
|
case rTxAGC_B_Mcs11_Mcs08:
|
index = 12;
|
break;
|
case rTxAGC_B_Mcs15_Mcs12:
|
index = 13;
|
break;
|
default:
|
DBG_871X("Invalid RegAddr 0x3%x in PHY_GetRateSectionIndexOfTxPowerByRate()", RegAddr);
|
break;
|
}
|
}
|
|
return index;
|
}
|
|
void
|
PHY_GetRateValuesOfTxPowerByRate(
|
struct adapter *padapter,
|
u32 RegAddr,
|
u32 BitMask,
|
u32 Value,
|
u8 *RateIndex,
|
s8 *PwrByRateVal,
|
u8 *RateNum
|
)
|
{
|
u8 i = 0;
|
|
switch (RegAddr) {
|
case rTxAGC_A_Rate18_06:
|
case rTxAGC_B_Rate18_06:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_6M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_9M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_12M);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_18M);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case rTxAGC_A_Rate54_24:
|
case rTxAGC_B_Rate54_24:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_24M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_36M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_48M);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_54M);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case rTxAGC_A_CCK1_Mcs32:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
|
PwrByRateVal[0] = (s8) ((((Value >> (8 + 4)) & 0xF)) * 10 +
|
((Value >> 8) & 0xF));
|
*RateNum = 1;
|
break;
|
|
case rTxAGC_B_CCK11_A_CCK2_11:
|
if (BitMask == 0xffffff00) {
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
|
for (i = 1; i < 4; ++i) {
|
PwrByRateVal[i - 1] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 3;
|
} else if (BitMask == 0x000000ff) {
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
|
PwrByRateVal[0] = (s8) ((((Value >> 4) & 0xF)) * 10 + (Value & 0xF));
|
*RateNum = 1;
|
}
|
break;
|
|
case rTxAGC_A_Mcs03_Mcs00:
|
case rTxAGC_B_Mcs03_Mcs00:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS0);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS1);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS2);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS3);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case rTxAGC_A_Mcs07_Mcs04:
|
case rTxAGC_B_Mcs07_Mcs04:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS4);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS5);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS6);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS7);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case rTxAGC_A_Mcs11_Mcs08:
|
case rTxAGC_B_Mcs11_Mcs08:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS8);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS9);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS10);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS11);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case rTxAGC_A_Mcs15_Mcs12:
|
case rTxAGC_B_Mcs15_Mcs12:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS12);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS13);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS14);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS15);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
|
break;
|
|
case rTxAGC_B_CCK1_55_Mcs32:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
|
for (i = 1; i < 4; ++i) {
|
PwrByRateVal[i - 1] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 3;
|
break;
|
|
case 0xC20:
|
case 0xE20:
|
case 0x1820:
|
case 0x1a20:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC24:
|
case 0xE24:
|
case 0x1824:
|
case 0x1a24:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_6M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_9M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_12M);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_18M);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC28:
|
case 0xE28:
|
case 0x1828:
|
case 0x1a28:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_24M);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_36M);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_48M);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_54M);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC2C:
|
case 0xE2C:
|
case 0x182C:
|
case 0x1a2C:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS0);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS1);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS2);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS3);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC30:
|
case 0xE30:
|
case 0x1830:
|
case 0x1a30:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS4);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS5);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS6);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS7);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC34:
|
case 0xE34:
|
case 0x1834:
|
case 0x1a34:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS8);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS9);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS10);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS11);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC38:
|
case 0xE38:
|
case 0x1838:
|
case 0x1a38:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS12);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS13);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS14);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS15);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC3C:
|
case 0xE3C:
|
case 0x183C:
|
case 0x1a3C:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS0);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS1);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS2);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS3);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC40:
|
case 0xE40:
|
case 0x1840:
|
case 0x1a40:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS4);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS5);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS6);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS7);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC44:
|
case 0xE44:
|
case 0x1844:
|
case 0x1a44:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS8);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS9);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS0);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS1);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC48:
|
case 0xE48:
|
case 0x1848:
|
case 0x1a48:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS2);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS3);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS4);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS5);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xC4C:
|
case 0xE4C:
|
case 0x184C:
|
case 0x1a4C:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS6);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS7);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS8);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS9);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xCD8:
|
case 0xED8:
|
case 0x18D8:
|
case 0x1aD8:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS16);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS17);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS18);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS19);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xCDC:
|
case 0xEDC:
|
case 0x18DC:
|
case 0x1aDC:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS20);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS21);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS22);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS23);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xCE0:
|
case 0xEE0:
|
case 0x18E0:
|
case 0x1aE0:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS0);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS1);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS2);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS3);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xCE4:
|
case 0xEE4:
|
case 0x18E4:
|
case 0x1aE4:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS4);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS5);
|
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS6);
|
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS7);
|
for (i = 0; i < 4; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
case 0xCE8:
|
case 0xEE8:
|
case 0x18E8:
|
case 0x1aE8:
|
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS8);
|
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS9);
|
for (i = 0; i < 2; ++i) {
|
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
|
((Value >> (i * 8)) & 0xF));
|
}
|
*RateNum = 4;
|
break;
|
|
default:
|
DBG_871X("Invalid RegAddr 0x%x in %s()\n", RegAddr, __func__);
|
break;
|
}
|
}
|
|
static void PHY_StoreTxPowerByRateNew(
|
struct adapter *padapter,
|
u32 Band,
|
u32 RfPath,
|
u32 TxNum,
|
u32 RegAddr,
|
u32 BitMask,
|
u32 Data
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
u8 i = 0, rateIndex[4] = {0}, rateNum = 0;
|
s8 PwrByRateVal[4] = {0};
|
|
PHY_GetRateValuesOfTxPowerByRate(padapter, RegAddr, BitMask, Data, rateIndex, PwrByRateVal, &rateNum);
|
|
if (Band != BAND_ON_2_4G && Band != BAND_ON_5G) {
|
DBG_871X("Invalid Band %d\n", Band);
|
return;
|
}
|
|
if (RfPath > ODM_RF_PATH_D) {
|
DBG_871X("Invalid RfPath %d\n", RfPath);
|
return;
|
}
|
|
if (TxNum > ODM_RF_PATH_D) {
|
DBG_871X("Invalid TxNum %d\n", TxNum);
|
return;
|
}
|
|
for (i = 0; i < rateNum; ++i) {
|
if (rateIndex[i] == PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS0) ||
|
rateIndex[i] == PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS1))
|
TxNum = RF_2TX;
|
|
pHalData->TxPwrByRateOffset[Band][RfPath][TxNum][rateIndex[i]] = PwrByRateVal[i];
|
}
|
}
|
|
static void PHY_StoreTxPowerByRateOld(
|
struct adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
u8 index = PHY_GetRateSectionIndexOfTxPowerByRate(padapter, RegAddr, BitMask);
|
|
pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][index] = Data;
|
/* DBG_871X("MCSTxPowerLevelOriginalOffset[%d][0] = 0x%x\n", pHalData->pwrGroupCnt, */
|
/* pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][0]); */
|
}
|
|
void PHY_InitTxPowerByRate(struct adapter *padapter)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
u8 band, rfPath, TxNum, rate;
|
|
for (band = BAND_ON_2_4G; band <= BAND_ON_5G; ++band)
|
for (rfPath = 0; rfPath < TX_PWR_BY_RATE_NUM_RF; ++rfPath)
|
for (TxNum = 0; TxNum < TX_PWR_BY_RATE_NUM_RF; ++TxNum)
|
for (rate = 0; rate < TX_PWR_BY_RATE_NUM_RATE; ++rate)
|
pHalData->TxPwrByRateOffset[band][rfPath][TxNum][rate] = 0;
|
}
|
|
void PHY_StoreTxPowerByRate(
|
struct adapter *padapter,
|
u32 Band,
|
u32 RfPath,
|
u32 TxNum,
|
u32 RegAddr,
|
u32 BitMask,
|
u32 Data
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
|
|
if (pDM_Odm->PhyRegPgVersion > 0)
|
PHY_StoreTxPowerByRateNew(padapter, Band, RfPath, TxNum, RegAddr, BitMask, Data);
|
else if (pDM_Odm->PhyRegPgVersion == 0) {
|
PHY_StoreTxPowerByRateOld(padapter, RegAddr, BitMask, Data);
|
|
if (RegAddr == rTxAGC_A_Mcs15_Mcs12 && pHalData->rf_type == RF_1T1R)
|
pHalData->pwrGroupCnt++;
|
else if (RegAddr == rTxAGC_B_Mcs15_Mcs12 && pHalData->rf_type != RF_1T1R)
|
pHalData->pwrGroupCnt++;
|
} else
|
DBG_871X("Invalid PHY_REG_PG.txt version %d\n", pDM_Odm->PhyRegPgVersion);
|
|
}
|
|
static void
|
phy_ConvertTxPowerByRateInDbmToRelativeValues(
|
struct adapter *padapter
|
)
|
{
|
u8 base = 0, i = 0, value = 0, band = 0, path = 0, txNum = 0;
|
u8 cckRates[4] = {
|
MGN_1M, MGN_2M, MGN_5_5M, MGN_11M
|
};
|
u8 ofdmRates[8] = {
|
MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M
|
};
|
u8 mcs0_7Rates[8] = {
|
MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7
|
};
|
u8 mcs8_15Rates[8] = {
|
MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15
|
};
|
u8 mcs16_23Rates[8] = {
|
MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23
|
};
|
u8 vht1ssRates[10] = {
|
MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4,
|
MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9
|
};
|
u8 vht2ssRates[10] = {
|
MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4,
|
MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9
|
};
|
u8 vht3ssRates[10] = {
|
MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4,
|
MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9
|
};
|
|
/* DBG_871X("===>PHY_ConvertTxPowerByRateInDbmToRelativeValues()\n"); */
|
|
for (band = BAND_ON_2_4G; band <= BAND_ON_5G; ++band) {
|
for (path = ODM_RF_PATH_A; path <= ODM_RF_PATH_D; ++path) {
|
for (txNum = RF_1TX; txNum < RF_MAX_TX_NUM; ++txNum) {
|
/* CCK */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_11M);
|
for (i = 0; i < ARRAY_SIZE(cckRates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, cckRates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, cckRates[i], value - base);
|
}
|
|
/* OFDM */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_54M);
|
for (i = 0; i < sizeof(ofdmRates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, ofdmRates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, ofdmRates[i], value - base);
|
}
|
|
/* HT MCS0~7 */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_MCS7);
|
for (i = 0; i < sizeof(mcs0_7Rates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, mcs0_7Rates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, mcs0_7Rates[i], value - base);
|
}
|
|
/* HT MCS8~15 */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_MCS15);
|
for (i = 0; i < sizeof(mcs8_15Rates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, mcs8_15Rates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, mcs8_15Rates[i], value - base);
|
}
|
|
/* HT MCS16~23 */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_MCS23);
|
for (i = 0; i < sizeof(mcs16_23Rates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, mcs16_23Rates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, mcs16_23Rates[i], value - base);
|
}
|
|
/* VHT 1SS */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_VHT1SS_MCS7);
|
for (i = 0; i < sizeof(vht1ssRates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, vht1ssRates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, vht1ssRates[i], value - base);
|
}
|
|
/* VHT 2SS */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_VHT2SS_MCS7);
|
for (i = 0; i < sizeof(vht2ssRates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, vht2ssRates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, vht2ssRates[i], value - base);
|
}
|
|
/* VHT 3SS */
|
base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_VHT3SS_MCS7);
|
for (i = 0; i < sizeof(vht3ssRates); ++i) {
|
value = PHY_GetTxPowerByRate(padapter, band, path, txNum, vht3ssRates[i]);
|
PHY_SetTxPowerByRate(padapter, band, path, txNum, vht3ssRates[i], value - base);
|
}
|
}
|
}
|
}
|
|
/* DBG_871X("<===PHY_ConvertTxPowerByRateInDbmToRelativeValues()\n"); */
|
}
|
|
/*
|
* This function must be called if the value in the PHY_REG_PG.txt(or header)
|
* is exact dBm values
|
*/
|
void PHY_TxPowerByRateConfiguration(struct adapter *padapter)
|
{
|
phy_StoreTxPowerByRateBase(padapter);
|
phy_ConvertTxPowerByRateInDbmToRelativeValues(padapter);
|
}
|
|
void PHY_SetTxPowerIndexByRateSection(
|
struct adapter *padapter, u8 RFPath, u8 Channel, u8 RateSection
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
|
if (RateSection == CCK) {
|
u8 cckRates[] = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M};
|
if (pHalData->CurrentBandType == BAND_ON_2_4G)
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, cckRates,
|
ARRAY_SIZE(cckRates));
|
|
} else if (RateSection == OFDM) {
|
u8 ofdmRates[] = {MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M};
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, ofdmRates,
|
ARRAY_SIZE(ofdmRates));
|
|
} else if (RateSection == HT_MCS0_MCS7) {
|
u8 htRates1T[] = {MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7};
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, htRates1T,
|
ARRAY_SIZE(htRates1T));
|
|
} else if (RateSection == HT_MCS8_MCS15) {
|
u8 htRates2T[] = {MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15};
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, htRates2T,
|
ARRAY_SIZE(htRates2T));
|
|
} else if (RateSection == HT_MCS16_MCS23) {
|
u8 htRates3T[] = {MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23};
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, htRates3T,
|
ARRAY_SIZE(htRates3T));
|
|
} else if (RateSection == HT_MCS24_MCS31) {
|
u8 htRates4T[] = {MGN_MCS24, MGN_MCS25, MGN_MCS26, MGN_MCS27, MGN_MCS28, MGN_MCS29, MGN_MCS30, MGN_MCS31};
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, htRates4T,
|
ARRAY_SIZE(htRates4T));
|
|
} else if (RateSection == VHT_1SSMCS0_1SSMCS9) {
|
u8 vhtRates1T[] = {MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4,
|
MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9};
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, vhtRates1T,
|
ARRAY_SIZE(vhtRates1T));
|
|
} else if (RateSection == VHT_2SSMCS0_2SSMCS9) {
|
u8 vhtRates2T[] = {MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4,
|
MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9};
|
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, vhtRates2T,
|
ARRAY_SIZE(vhtRates2T));
|
} else if (RateSection == VHT_3SSMCS0_3SSMCS9) {
|
u8 vhtRates3T[] = {MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4,
|
MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9};
|
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, vhtRates3T,
|
ARRAY_SIZE(vhtRates3T));
|
} else if (RateSection == VHT_4SSMCS0_4SSMCS9) {
|
u8 vhtRates4T[] = {MGN_VHT4SS_MCS0, MGN_VHT4SS_MCS1, MGN_VHT4SS_MCS2, MGN_VHT4SS_MCS3, MGN_VHT4SS_MCS4,
|
MGN_VHT4SS_MCS5, MGN_VHT4SS_MCS6, MGN_VHT4SS_MCS7, MGN_VHT4SS_MCS8, MGN_VHT4SS_MCS9};
|
|
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
|
pHalData->CurrentChannelBW,
|
Channel, vhtRates4T,
|
ARRAY_SIZE(vhtRates4T));
|
} else
|
DBG_871X("Invalid RateSection %d in %s", RateSection, __func__);
|
}
|
|
static bool phy_GetChnlIndex(u8 Channel, u8 *ChannelIdx)
|
{
|
u8 channel5G[CHANNEL_MAX_NUMBER_5G] = {
|
36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 100, 102,
|
104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130,
|
132, 134, 136, 138, 140, 142, 144, 149, 151, 153, 155, 157, 159, 161,
|
163, 165, 167, 168, 169, 171, 173, 175, 177
|
};
|
u8 i = 0;
|
bool bIn24G = true;
|
|
if (Channel <= 14) {
|
bIn24G = true;
|
*ChannelIdx = Channel-1;
|
} else {
|
bIn24G = false;
|
|
for (i = 0; i < ARRAY_SIZE(channel5G); ++i) {
|
if (channel5G[i] == Channel) {
|
*ChannelIdx = i;
|
return bIn24G;
|
}
|
}
|
}
|
|
return bIn24G;
|
}
|
|
u8 PHY_GetTxPowerIndexBase(
|
struct adapter *padapter,
|
u8 RFPath,
|
u8 Rate,
|
enum CHANNEL_WIDTH BandWidth,
|
u8 Channel,
|
bool *bIn24G
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
u8 i = 0; /* default set to 1S */
|
u8 txPower = 0;
|
u8 chnlIdx = (Channel-1);
|
|
if (HAL_IsLegalChannel(padapter, Channel) == false) {
|
chnlIdx = 0;
|
DBG_871X("Illegal channel!!\n");
|
}
|
|
*bIn24G = phy_GetChnlIndex(Channel, &chnlIdx);
|
|
/* DBG_871X("[%s] Channel Index: %d\n", (*bIn24G?"2.4G":"5G"), chnlIdx); */
|
|
if (*bIn24G) { /* 3 ============================== 2.4 G ============================== */
|
if (IS_CCK_RATE(Rate))
|
txPower = pHalData->Index24G_CCK_Base[RFPath][chnlIdx];
|
else if (MGN_6M <= Rate)
|
txPower = pHalData->Index24G_BW40_Base[RFPath][chnlIdx];
|
else
|
DBG_871X("PHY_GetTxPowerIndexBase: INVALID Rate.\n");
|
|
/* DBG_871X("Base Tx power(RF-%c, Rate #%d, Channel Index %d) = 0x%X\n", */
|
/* ((RFPath == 0)?'A':'B'), Rate, chnlIdx, txPower); */
|
|
/* OFDM-1T */
|
if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate)) {
|
txPower += pHalData->OFDM_24G_Diff[RFPath][TX_1S];
|
/* DBG_871X("+PowerDiff 2.4G (RF-%c): (OFDM-1T) = (%d)\n", ((RFPath == 0)?'A':'B'), pHalData->OFDM_24G_Diff[RFPath][TX_1S]); */
|
}
|
if (BandWidth == CHANNEL_WIDTH_20) { /* BW20-1S, BW20-2S */
|
if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_24G_Diff[RFPath][TX_1S];
|
if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_24G_Diff[RFPath][TX_2S];
|
if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_24G_Diff[RFPath][TX_3S];
|
if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_24G_Diff[RFPath][TX_4S];
|
|
/* DBG_871X("+PowerDiff 2.4G (RF-%c): (BW20-1S, BW20-2S, BW20-3S, BW20-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
|
/* pHalData->BW20_24G_Diff[RFPath][TX_1S], pHalData->BW20_24G_Diff[RFPath][TX_2S], */
|
/* pHalData->BW20_24G_Diff[RFPath][TX_3S], pHalData->BW20_24G_Diff[RFPath][TX_4S]); */
|
} else if (BandWidth == CHANNEL_WIDTH_40) { /* BW40-1S, BW40-2S */
|
if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
|
if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_2S];
|
if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_3S];
|
if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_4S];
|
|
/* DBG_871X("+PowerDiff 2.4G (RF-%c): (BW40-1S, BW40-2S, BW40-3S, BW40-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
|
/* pHalData->BW40_24G_Diff[RFPath][TX_1S], pHalData->BW40_24G_Diff[RFPath][TX_2S], */
|
/* pHalData->BW40_24G_Diff[RFPath][TX_3S], pHalData->BW40_24G_Diff[RFPath][TX_4S]); */
|
}
|
/* Willis suggest adopt BW 40M power index while in BW 80 mode */
|
else if (BandWidth == CHANNEL_WIDTH_80) {
|
if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
|
if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_2S];
|
if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_3S];
|
if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_24G_Diff[RFPath][TX_4S];
|
|
/* DBG_871X("+PowerDiff 2.4G (RF-%c): (BW40-1S, BW40-2S, BW40-3S, BW40-4T) = (%d, %d, %d, %d) P.S. Current is in BW 80MHz\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
|
/* pHalData->BW40_24G_Diff[RFPath][TX_1S], pHalData->BW40_24G_Diff[RFPath][TX_2S], */
|
/* pHalData->BW40_24G_Diff[RFPath][TX_3S], pHalData->BW40_24G_Diff[RFPath][TX_4S]); */
|
}
|
} else {/* 3 ============================== 5 G ============================== */
|
if (MGN_6M <= Rate)
|
txPower = pHalData->Index5G_BW40_Base[RFPath][chnlIdx];
|
else
|
DBG_871X("===> mpt_ProQueryCalTxPower_Jaguar: INVALID Rate.\n");
|
|
/* DBG_871X("Base Tx power(RF-%c, Rate #%d, Channel Index %d) = 0x%X\n", */
|
/* ((RFPath == 0)?'A':'B'), Rate, chnlIdx, txPower); */
|
|
/* OFDM-1T */
|
if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate)) {
|
txPower += pHalData->OFDM_5G_Diff[RFPath][TX_1S];
|
/* DBG_871X("+PowerDiff 5G (RF-%c): (OFDM-1T) = (%d)\n", ((RFPath == 0)?'A':'B'), pHalData->OFDM_5G_Diff[RFPath][TX_1S]); */
|
}
|
|
/* BW20-1S, BW20-2S */
|
if (BandWidth == CHANNEL_WIDTH_20) {
|
if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_5G_Diff[RFPath][TX_1S];
|
if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_5G_Diff[RFPath][TX_2S];
|
if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_5G_Diff[RFPath][TX_3S];
|
if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW20_5G_Diff[RFPath][TX_4S];
|
|
/* DBG_871X("+PowerDiff 5G (RF-%c): (BW20-1S, BW20-2S, BW20-3S, BW20-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
|
/* pHalData->BW20_5G_Diff[RFPath][TX_1S], pHalData->BW20_5G_Diff[RFPath][TX_2S], */
|
/* pHalData->BW20_5G_Diff[RFPath][TX_3S], pHalData->BW20_5G_Diff[RFPath][TX_4S]); */
|
} else if (BandWidth == CHANNEL_WIDTH_40) { /* BW40-1S, BW40-2S */
|
if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_5G_Diff[RFPath][TX_1S];
|
if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_5G_Diff[RFPath][TX_2S];
|
if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_5G_Diff[RFPath][TX_3S];
|
if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW40_5G_Diff[RFPath][TX_4S];
|
|
/* DBG_871X("+PowerDiff 5G(RF-%c): (BW40-1S, BW40-2S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
|
/* pHalData->BW40_5G_Diff[RFPath][TX_1S], pHalData->BW40_5G_Diff[RFPath][TX_2S], */
|
/* pHalData->BW40_5G_Diff[RFPath][TX_3S], pHalData->BW40_5G_Diff[RFPath][TX_4S]); */
|
} else if (BandWidth == CHANNEL_WIDTH_80) { /* BW80-1S, BW80-2S */
|
/* <20121220, Kordan> Get the index of array "Index5G_BW80_Base". */
|
u8 channel5G_80M[CHANNEL_MAX_NUMBER_5G_80M] = {42, 58, 106, 122, 138, 155, 171};
|
for (i = 0; i < ARRAY_SIZE(channel5G_80M); ++i)
|
if (channel5G_80M[i] == Channel)
|
chnlIdx = i;
|
|
txPower = pHalData->Index5G_BW80_Base[RFPath][chnlIdx];
|
|
if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += + pHalData->BW80_5G_Diff[RFPath][TX_1S];
|
if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW80_5G_Diff[RFPath][TX_2S];
|
if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW80_5G_Diff[RFPath][TX_3S];
|
if ((MGN_MCS23 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
|
txPower += pHalData->BW80_5G_Diff[RFPath][TX_4S];
|
|
/* DBG_871X("+PowerDiff 5G(RF-%c): (BW80-1S, BW80-2S, BW80-3S, BW80-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
|
/* pHalData->BW80_5G_Diff[RFPath][TX_1S], pHalData->BW80_5G_Diff[RFPath][TX_2S], */
|
/* pHalData->BW80_5G_Diff[RFPath][TX_3S], pHalData->BW80_5G_Diff[RFPath][TX_4S]); */
|
}
|
}
|
|
return txPower;
|
}
|
|
s8 PHY_GetTxPowerTrackingOffset(struct adapter *padapter, u8 RFPath, u8 Rate)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
|
s8 offset = 0;
|
|
if (pDM_Odm->RFCalibrateInfo.TxPowerTrackControl == false)
|
return offset;
|
|
if ((Rate == MGN_1M) || (Rate == MGN_2M) || (Rate == MGN_5_5M) || (Rate == MGN_11M)) {
|
offset = pDM_Odm->Remnant_CCKSwingIdx;
|
/* DBG_871X("+Remnant_CCKSwingIdx = 0x%x\n", RFPath, Rate, pDM_Odm->Remnant_CCKSwingIdx); */
|
} else {
|
offset = pDM_Odm->Remnant_OFDMSwingIdx[RFPath];
|
/* DBG_871X("+Remanant_OFDMSwingIdx[RFPath %u][Rate 0x%x] = 0x%x\n", RFPath, Rate, pDM_Odm->Remnant_OFDMSwingIdx[RFPath]); */
|
|
}
|
|
return offset;
|
}
|
|
u8 PHY_GetRateIndexOfTxPowerByRate(u8 Rate)
|
{
|
u8 index = 0;
|
switch (Rate) {
|
case MGN_1M:
|
index = 0;
|
break;
|
case MGN_2M:
|
index = 1;
|
break;
|
case MGN_5_5M:
|
index = 2;
|
break;
|
case MGN_11M:
|
index = 3;
|
break;
|
case MGN_6M:
|
index = 4;
|
break;
|
case MGN_9M:
|
index = 5;
|
break;
|
case MGN_12M:
|
index = 6;
|
break;
|
case MGN_18M:
|
index = 7;
|
break;
|
case MGN_24M:
|
index = 8;
|
break;
|
case MGN_36M:
|
index = 9;
|
break;
|
case MGN_48M:
|
index = 10;
|
break;
|
case MGN_54M:
|
index = 11;
|
break;
|
case MGN_MCS0:
|
index = 12;
|
break;
|
case MGN_MCS1:
|
index = 13;
|
break;
|
case MGN_MCS2:
|
index = 14;
|
break;
|
case MGN_MCS3:
|
index = 15;
|
break;
|
case MGN_MCS4:
|
index = 16;
|
break;
|
case MGN_MCS5:
|
index = 17;
|
break;
|
case MGN_MCS6:
|
index = 18;
|
break;
|
case MGN_MCS7:
|
index = 19;
|
break;
|
case MGN_MCS8:
|
index = 20;
|
break;
|
case MGN_MCS9:
|
index = 21;
|
break;
|
case MGN_MCS10:
|
index = 22;
|
break;
|
case MGN_MCS11:
|
index = 23;
|
break;
|
case MGN_MCS12:
|
index = 24;
|
break;
|
case MGN_MCS13:
|
index = 25;
|
break;
|
case MGN_MCS14:
|
index = 26;
|
break;
|
case MGN_MCS15:
|
index = 27;
|
break;
|
case MGN_MCS16:
|
index = 28;
|
break;
|
case MGN_MCS17:
|
index = 29;
|
break;
|
case MGN_MCS18:
|
index = 30;
|
break;
|
case MGN_MCS19:
|
index = 31;
|
break;
|
case MGN_MCS20:
|
index = 32;
|
break;
|
case MGN_MCS21:
|
index = 33;
|
break;
|
case MGN_MCS22:
|
index = 34;
|
break;
|
case MGN_MCS23:
|
index = 35;
|
break;
|
case MGN_MCS24:
|
index = 36;
|
break;
|
case MGN_MCS25:
|
index = 37;
|
break;
|
case MGN_MCS26:
|
index = 38;
|
break;
|
case MGN_MCS27:
|
index = 39;
|
break;
|
case MGN_MCS28:
|
index = 40;
|
break;
|
case MGN_MCS29:
|
index = 41;
|
break;
|
case MGN_MCS30:
|
index = 42;
|
break;
|
case MGN_MCS31:
|
index = 43;
|
break;
|
case MGN_VHT1SS_MCS0:
|
index = 44;
|
break;
|
case MGN_VHT1SS_MCS1:
|
index = 45;
|
break;
|
case MGN_VHT1SS_MCS2:
|
index = 46;
|
break;
|
case MGN_VHT1SS_MCS3:
|
index = 47;
|
break;
|
case MGN_VHT1SS_MCS4:
|
index = 48;
|
break;
|
case MGN_VHT1SS_MCS5:
|
index = 49;
|
break;
|
case MGN_VHT1SS_MCS6:
|
index = 50;
|
break;
|
case MGN_VHT1SS_MCS7:
|
index = 51;
|
break;
|
case MGN_VHT1SS_MCS8:
|
index = 52;
|
break;
|
case MGN_VHT1SS_MCS9:
|
index = 53;
|
break;
|
case MGN_VHT2SS_MCS0:
|
index = 54;
|
break;
|
case MGN_VHT2SS_MCS1:
|
index = 55;
|
break;
|
case MGN_VHT2SS_MCS2:
|
index = 56;
|
break;
|
case MGN_VHT2SS_MCS3:
|
index = 57;
|
break;
|
case MGN_VHT2SS_MCS4:
|
index = 58;
|
break;
|
case MGN_VHT2SS_MCS5:
|
index = 59;
|
break;
|
case MGN_VHT2SS_MCS6:
|
index = 60;
|
break;
|
case MGN_VHT2SS_MCS7:
|
index = 61;
|
break;
|
case MGN_VHT2SS_MCS8:
|
index = 62;
|
break;
|
case MGN_VHT2SS_MCS9:
|
index = 63;
|
break;
|
case MGN_VHT3SS_MCS0:
|
index = 64;
|
break;
|
case MGN_VHT3SS_MCS1:
|
index = 65;
|
break;
|
case MGN_VHT3SS_MCS2:
|
index = 66;
|
break;
|
case MGN_VHT3SS_MCS3:
|
index = 67;
|
break;
|
case MGN_VHT3SS_MCS4:
|
index = 68;
|
break;
|
case MGN_VHT3SS_MCS5:
|
index = 69;
|
break;
|
case MGN_VHT3SS_MCS6:
|
index = 70;
|
break;
|
case MGN_VHT3SS_MCS7:
|
index = 71;
|
break;
|
case MGN_VHT3SS_MCS8:
|
index = 72;
|
break;
|
case MGN_VHT3SS_MCS9:
|
index = 73;
|
break;
|
case MGN_VHT4SS_MCS0:
|
index = 74;
|
break;
|
case MGN_VHT4SS_MCS1:
|
index = 75;
|
break;
|
case MGN_VHT4SS_MCS2:
|
index = 76;
|
break;
|
case MGN_VHT4SS_MCS3:
|
index = 77;
|
break;
|
case MGN_VHT4SS_MCS4:
|
index = 78;
|
break;
|
case MGN_VHT4SS_MCS5:
|
index = 79;
|
break;
|
case MGN_VHT4SS_MCS6:
|
index = 80;
|
break;
|
case MGN_VHT4SS_MCS7:
|
index = 81;
|
break;
|
case MGN_VHT4SS_MCS8:
|
index = 82;
|
break;
|
case MGN_VHT4SS_MCS9:
|
index = 83;
|
break;
|
default:
|
DBG_871X("Invalid rate 0x%x in %s\n", Rate, __func__);
|
break;
|
}
|
return index;
|
}
|
|
s8 PHY_GetTxPowerByRate(
|
struct adapter *padapter, u8 Band, u8 RFPath, u8 TxNum, u8 Rate
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
s8 value = 0;
|
u8 rateIndex = PHY_GetRateIndexOfTxPowerByRate(Rate);
|
|
if ((padapter->registrypriv.RegEnableTxPowerByRate == 2 && pHalData->EEPROMRegulatory == 2) ||
|
padapter->registrypriv.RegEnableTxPowerByRate == 0)
|
return 0;
|
|
if (Band != BAND_ON_2_4G && Band != BAND_ON_5G) {
|
DBG_871X("Invalid band %d in %s\n", Band, __func__);
|
return value;
|
}
|
if (RFPath > ODM_RF_PATH_D) {
|
DBG_871X("Invalid RfPath %d in %s\n", RFPath, __func__);
|
return value;
|
}
|
if (TxNum >= RF_MAX_TX_NUM) {
|
DBG_871X("Invalid TxNum %d in %s\n", TxNum, __func__);
|
return value;
|
}
|
if (rateIndex >= TX_PWR_BY_RATE_NUM_RATE) {
|
DBG_871X("Invalid RateIndex %d in %s\n", rateIndex, __func__);
|
return value;
|
}
|
|
return pHalData->TxPwrByRateOffset[Band][RFPath][TxNum][rateIndex];
|
|
}
|
|
void PHY_SetTxPowerByRate(
|
struct adapter *padapter,
|
u8 Band,
|
u8 RFPath,
|
u8 TxNum,
|
u8 Rate,
|
s8 Value
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
u8 rateIndex = PHY_GetRateIndexOfTxPowerByRate(Rate);
|
|
if (Band != BAND_ON_2_4G && Band != BAND_ON_5G) {
|
DBG_871X("Invalid band %d in %s\n", Band, __func__);
|
return;
|
}
|
if (RFPath > ODM_RF_PATH_D) {
|
DBG_871X("Invalid RfPath %d in %s\n", RFPath, __func__);
|
return;
|
}
|
if (TxNum >= RF_MAX_TX_NUM) {
|
DBG_871X("Invalid TxNum %d in %s\n", TxNum, __func__);
|
return;
|
}
|
if (rateIndex >= TX_PWR_BY_RATE_NUM_RATE) {
|
DBG_871X("Invalid RateIndex %d in %s\n", rateIndex, __func__);
|
return;
|
}
|
|
pHalData->TxPwrByRateOffset[Band][RFPath][TxNum][rateIndex] = Value;
|
}
|
|
void PHY_SetTxPowerLevelByPath(struct adapter *Adapter, u8 channel, u8 path)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
bool bIsIn24G = (pHalData->CurrentBandType == BAND_ON_2_4G);
|
|
/* if (pMgntInfo->RegNByteAccess == 0) */
|
{
|
if (bIsIn24G)
|
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, CCK);
|
|
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, OFDM);
|
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, HT_MCS0_MCS7);
|
|
if (pHalData->NumTotalRFPath >= 2)
|
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, HT_MCS8_MCS15);
|
|
}
|
}
|
|
void PHY_SetTxPowerIndexByRateArray(
|
struct adapter *padapter,
|
u8 RFPath,
|
enum CHANNEL_WIDTH BandWidth,
|
u8 Channel,
|
u8 *Rates,
|
u8 RateArraySize
|
)
|
{
|
u32 powerIndex = 0;
|
int i = 0;
|
|
for (i = 0; i < RateArraySize; ++i) {
|
powerIndex = PHY_GetTxPowerIndex(padapter, RFPath, Rates[i], BandWidth, Channel);
|
PHY_SetTxPowerIndex(padapter, powerIndex, RFPath, Rates[i]);
|
}
|
}
|
|
static s8 phy_GetWorldWideLimit(s8 *LimitTable)
|
{
|
s8 min = LimitTable[0];
|
u8 i = 0;
|
|
for (i = 0; i < MAX_REGULATION_NUM; ++i) {
|
if (LimitTable[i] < min)
|
min = LimitTable[i];
|
}
|
|
return min;
|
}
|
|
static s8 phy_GetChannelIndexOfTxPowerLimit(u8 Band, u8 Channel)
|
{
|
s8 channelIndex = -1;
|
u8 channel5G[CHANNEL_MAX_NUMBER_5G] = {
|
36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 100, 102,
|
104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130,
|
132, 134, 136, 138, 140, 142, 144, 149, 151, 153, 155, 157, 159, 161,
|
163, 165, 167, 168, 169, 171, 173, 175, 177
|
};
|
u8 i = 0;
|
if (Band == BAND_ON_2_4G)
|
channelIndex = Channel - 1;
|
else if (Band == BAND_ON_5G) {
|
for (i = 0; i < ARRAY_SIZE(channel5G); ++i) {
|
if (channel5G[i] == Channel)
|
channelIndex = i;
|
}
|
} else
|
DBG_871X("Invalid Band %d in %s", Band, __func__);
|
|
if (channelIndex == -1)
|
DBG_871X("Invalid Channel %d of Band %d in %s", Channel, Band, __func__);
|
|
return channelIndex;
|
}
|
|
static s16 get_bandwidth_idx(const enum CHANNEL_WIDTH bandwidth)
|
{
|
switch (bandwidth) {
|
case CHANNEL_WIDTH_20:
|
return 0;
|
case CHANNEL_WIDTH_40:
|
return 1;
|
case CHANNEL_WIDTH_80:
|
return 2;
|
case CHANNEL_WIDTH_160:
|
return 3;
|
default:
|
return -1;
|
}
|
}
|
|
static s16 get_rate_sctn_idx(const u8 rate)
|
{
|
switch (rate) {
|
case MGN_1M: case MGN_2M: case MGN_5_5M: case MGN_11M:
|
return 0;
|
case MGN_6M: case MGN_9M: case MGN_12M: case MGN_18M:
|
case MGN_24M: case MGN_36M: case MGN_48M: case MGN_54M:
|
return 1;
|
case MGN_MCS0: case MGN_MCS1: case MGN_MCS2: case MGN_MCS3:
|
case MGN_MCS4: case MGN_MCS5: case MGN_MCS6: case MGN_MCS7:
|
return 2;
|
case MGN_MCS8: case MGN_MCS9: case MGN_MCS10: case MGN_MCS11:
|
case MGN_MCS12: case MGN_MCS13: case MGN_MCS14: case MGN_MCS15:
|
return 3;
|
case MGN_MCS16: case MGN_MCS17: case MGN_MCS18: case MGN_MCS19:
|
case MGN_MCS20: case MGN_MCS21: case MGN_MCS22: case MGN_MCS23:
|
return 4;
|
case MGN_MCS24: case MGN_MCS25: case MGN_MCS26: case MGN_MCS27:
|
case MGN_MCS28: case MGN_MCS29: case MGN_MCS30: case MGN_MCS31:
|
return 5;
|
case MGN_VHT1SS_MCS0: case MGN_VHT1SS_MCS1: case MGN_VHT1SS_MCS2:
|
case MGN_VHT1SS_MCS3: case MGN_VHT1SS_MCS4: case MGN_VHT1SS_MCS5:
|
case MGN_VHT1SS_MCS6: case MGN_VHT1SS_MCS7: case MGN_VHT1SS_MCS8:
|
case MGN_VHT1SS_MCS9:
|
return 6;
|
case MGN_VHT2SS_MCS0: case MGN_VHT2SS_MCS1: case MGN_VHT2SS_MCS2:
|
case MGN_VHT2SS_MCS3: case MGN_VHT2SS_MCS4: case MGN_VHT2SS_MCS5:
|
case MGN_VHT2SS_MCS6: case MGN_VHT2SS_MCS7: case MGN_VHT2SS_MCS8:
|
case MGN_VHT2SS_MCS9:
|
return 7;
|
case MGN_VHT3SS_MCS0: case MGN_VHT3SS_MCS1: case MGN_VHT3SS_MCS2:
|
case MGN_VHT3SS_MCS3: case MGN_VHT3SS_MCS4: case MGN_VHT3SS_MCS5:
|
case MGN_VHT3SS_MCS6: case MGN_VHT3SS_MCS7: case MGN_VHT3SS_MCS8:
|
case MGN_VHT3SS_MCS9:
|
return 8;
|
case MGN_VHT4SS_MCS0: case MGN_VHT4SS_MCS1: case MGN_VHT4SS_MCS2:
|
case MGN_VHT4SS_MCS3: case MGN_VHT4SS_MCS4: case MGN_VHT4SS_MCS5:
|
case MGN_VHT4SS_MCS6: case MGN_VHT4SS_MCS7: case MGN_VHT4SS_MCS8:
|
case MGN_VHT4SS_MCS9:
|
return 9;
|
default:
|
DBG_871X("Wrong rate 0x%x\n", rate);
|
return -1;
|
}
|
}
|
|
s8 phy_get_tx_pwr_lmt(struct adapter *adapter, u32 reg_pwr_tbl_sel,
|
enum BAND_TYPE band_type, enum CHANNEL_WIDTH bandwidth,
|
u8 rf_path, u8 data_rate, u8 channel)
|
{
|
s16 idx_band = -1;
|
s16 idx_regulation = -1;
|
s16 idx_bandwidth = -1;
|
s16 idx_rate_sctn = -1;
|
s16 idx_channel = -1;
|
s8 pwr_lmt = MAX_POWER_INDEX;
|
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
|
|
if (((adapter->registrypriv.RegEnableTxPowerLimit == 2) &&
|
(hal_data->EEPROMRegulatory != 1)) ||
|
(adapter->registrypriv.RegEnableTxPowerLimit == 0))
|
return MAX_POWER_INDEX;
|
|
switch (adapter->registrypriv.RegPwrTblSel) {
|
case 1:
|
idx_regulation = TXPWR_LMT_ETSI;
|
break;
|
case 2:
|
idx_regulation = TXPWR_LMT_MKK;
|
break;
|
case 3:
|
idx_regulation = TXPWR_LMT_FCC;
|
break;
|
case 4:
|
idx_regulation = TXPWR_LMT_WW;
|
break;
|
default:
|
idx_regulation = (band_type == BAND_ON_2_4G) ?
|
hal_data->Regulation2_4G :
|
hal_data->Regulation5G;
|
break;
|
}
|
|
/* DBG_871X("pMgntInfo->RegPwrTblSel %d, final regulation %d\n", */
|
/* adapter->registrypriv.RegPwrTblSel, idx_regulation); */
|
|
if (band_type == BAND_ON_2_4G)
|
idx_band = 0;
|
else if (band_type == BAND_ON_5G)
|
idx_band = 1;
|
|
idx_bandwidth = get_bandwidth_idx(bandwidth);
|
idx_rate_sctn = get_rate_sctn_idx(data_rate);
|
|
if (band_type == BAND_ON_5G && idx_rate_sctn == 0)
|
DBG_871X("Wrong rate 0x%x: No CCK in 5G Band\n", DataRate);
|
|
/* workaround for wrong index combination to obtain tx power limit, */
|
/* OFDM only exists in BW 20M */
|
/* CCK table will only be given in BW 20M */
|
/* HT on 80M will reference to HT on 40M */
|
if (idx_rate_sctn == 0 || idx_rate_sctn == 1)
|
idx_bandwidth = 0;
|
else if ((idx_rate_sctn == 2 || idx_rate_sctn == 3) &&
|
(band_type == BAND_ON_5G) && (idx_bandwidth == 2))
|
idx_bandwidth = 1;
|
|
if (band_type == BAND_ON_2_4G || band_type == BAND_ON_5G)
|
channel = phy_GetChannelIndexOfTxPowerLimit(band_type, channel);
|
|
if (idx_band == -1 || idx_regulation == -1 || idx_bandwidth == -1 ||
|
idx_rate_sctn == -1 || idx_channel == -1) {
|
/* DBG_871X("Wrong index value to access power limit table [band %d][regulation %d][bandwidth %d][rf_path %d][rate_section %d][chnlGroup %d]\n", */
|
/* idx_band, idx_regulation, idx_bandwidth, rf_path, */
|
/* idx_rate_sctn, channel); */
|
|
return MAX_POWER_INDEX;
|
}
|
|
if (band_type == BAND_ON_2_4G) {
|
s8 limits[10] = {0}; u8 i = 0;
|
|
for (i = 0; i < MAX_REGULATION_NUM; i++)
|
limits[i] = hal_data->TxPwrLimit_2_4G[i]
|
[idx_bandwidth]
|
[idx_rate_sctn]
|
[idx_channel]
|
[rf_path];
|
|
pwr_lmt = (idx_regulation == TXPWR_LMT_WW) ?
|
phy_GetWorldWideLimit(limits) :
|
hal_data->TxPwrLimit_2_4G[idx_regulation]
|
[idx_bandwidth]
|
[idx_rate_sctn]
|
[idx_channel]
|
[rf_path];
|
|
} else if (band_type == BAND_ON_5G) {
|
s8 limits[10] = {0}; u8 i = 0;
|
|
for (i = 0; i < MAX_REGULATION_NUM; ++i)
|
limits[i] = hal_data->TxPwrLimit_5G[i]
|
[idx_bandwidth]
|
[idx_rate_sctn]
|
[idx_channel]
|
[rf_path];
|
|
pwr_lmt = (idx_regulation == TXPWR_LMT_WW) ?
|
phy_GetWorldWideLimit(limits) :
|
hal_data->TxPwrLimit_5G[idx_regulation]
|
[idx_bandwidth]
|
[idx_rate_sctn]
|
[idx_channel]
|
[rf_path];
|
} else {
|
DBG_871X("No power limit table of the specified band\n");
|
}
|
|
/* combine 5G VHT & HT rate */
|
/* 5G 20M and 40M HT and VHT can cross reference */
|
/*
|
if (band_type == BAND_ON_5G && pwr_lmt == MAX_POWER_INDEX) {
|
if (idx_bandwidth == 0 || idx_bandwidth == 1) {
|
RT_TRACE(COMP_INIT, DBG_LOUD, ("No power limit table of the specified band %d, bandwidth %d, ratesection %d, rf path %d\n",
|
idx_band, idx_bandwidth,
|
idx_rate_sctn, rf_path));
|
if (idx_rate_sctn == 2)
|
pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][4][idx_channel][rf_path];
|
else if (idx_rate_sctn == 4)
|
pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][2][idx_channel][rf_path];
|
else if (idx_rate_sctn == 3)
|
pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][5][idx_channel][rf_path];
|
else if (idx_rate_sctn == 5)
|
pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][3][idx_channel][rf_path];
|
}
|
}
|
*/
|
|
/* DBG_871X("TxPwrLmt[Regulation %d][Band %d][BW %d][RFPath %d][Rate 0x%x][Chnl %d] = %d\n", */
|
/* idx_regulation, hal_data->CurrentBandType, bandwidth, rf_path, data_rate, channel, pwr_lmt); */
|
return pwr_lmt;
|
}
|
|
static void phy_CrossReferenceHTAndVHTTxPowerLimit(struct adapter *padapter)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
|
u8 regulation, bw, channel, rateSection;
|
s8 tempPwrLmt = 0;
|
|
for (regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation) {
|
for (bw = 0; bw < MAX_5G_BANDWIDTH_NUM; ++bw) {
|
for (channel = 0; channel < CHANNEL_MAX_NUMBER_5G; ++channel) {
|
for (rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection) {
|
tempPwrLmt = pHalData->TxPwrLimit_5G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
|
if (tempPwrLmt == MAX_POWER_INDEX) {
|
u8 baseSection = 2, refSection = 6;
|
if (bw == 0 || bw == 1) { /* 5G 20M 40M VHT and HT can cross reference */
|
/* DBG_871X("No power limit table of the specified band %d, bandwidth %d, ratesection %d, channel %d, rf path %d\n", */
|
/* 1, bw, rateSection, channel, ODM_RF_PATH_A); */
|
if (rateSection >= 2 && rateSection <= 9) {
|
if (rateSection == 2) {
|
baseSection = 2;
|
refSection = 6;
|
} else if (rateSection == 3) {
|
baseSection = 3;
|
refSection = 7;
|
} else if (rateSection == 4) {
|
baseSection = 4;
|
refSection = 8;
|
} else if (rateSection == 5) {
|
baseSection = 5;
|
refSection = 9;
|
} else if (rateSection == 6) {
|
baseSection = 6;
|
refSection = 2;
|
} else if (rateSection == 7) {
|
baseSection = 7;
|
refSection = 3;
|
} else if (rateSection == 8) {
|
baseSection = 8;
|
refSection = 4;
|
} else if (rateSection == 9) {
|
baseSection = 9;
|
refSection = 5;
|
}
|
pHalData->TxPwrLimit_5G[regulation][bw][baseSection][channel][ODM_RF_PATH_A] =
|
pHalData->TxPwrLimit_5G[regulation][bw][refSection][channel][ODM_RF_PATH_A];
|
}
|
|
/* DBG_871X("use other value %d", tempPwrLmt); */
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
void PHY_ConvertTxPowerLimitToPowerIndex(struct adapter *Adapter)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
u8 BW40PwrBasedBm2_4G = 0x2E;
|
u8 regulation, bw, channel, rateSection;
|
s8 tempValue = 0, tempPwrLmt = 0;
|
u8 rfPath = 0;
|
|
/* DBG_871X("=====> PHY_ConvertTxPowerLimitToPowerIndex()\n"); */
|
|
phy_CrossReferenceHTAndVHTTxPowerLimit(Adapter);
|
|
for (regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation) {
|
for (bw = 0; bw < MAX_2_4G_BANDWIDTH_NUM; ++bw) {
|
for (channel = 0; channel < CHANNEL_MAX_NUMBER_2G; ++channel) {
|
for (rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection) {
|
tempPwrLmt = pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
|
|
for (rfPath = ODM_RF_PATH_A; rfPath < MAX_RF_PATH_NUM; ++rfPath) {
|
if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE) {
|
if (rateSection == 5) /* HT 4T */
|
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_4TX, HT_MCS24_MCS31);
|
else if (rateSection == 4) /* HT 3T */
|
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_3TX, HT_MCS16_MCS23);
|
else if (rateSection == 3) /* HT 2T */
|
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_2TX, HT_MCS8_MCS15);
|
else if (rateSection == 2) /* HT 1T */
|
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_1TX, HT_MCS0_MCS7);
|
else if (rateSection == 1) /* OFDM */
|
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_1TX, OFDM);
|
else if (rateSection == 0) /* CCK */
|
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_1TX, CCK);
|
} else
|
BW40PwrBasedBm2_4G = Adapter->registrypriv.RegPowerBase * 2;
|
|
if (tempPwrLmt != MAX_POWER_INDEX) {
|
tempValue = tempPwrLmt - BW40PwrBasedBm2_4G;
|
pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][rfPath] = tempValue;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/* DBG_871X("<===== PHY_ConvertTxPowerLimitToPowerIndex()\n"); */
|
}
|
|
void PHY_InitTxPowerLimit(struct adapter *Adapter)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
u8 i, j, k, l, m;
|
|
/* DBG_871X("=====> PHY_InitTxPowerLimit()!\n"); */
|
|
for (i = 0; i < MAX_REGULATION_NUM; ++i) {
|
for (j = 0; j < MAX_2_4G_BANDWIDTH_NUM; ++j)
|
for (k = 0; k < MAX_RATE_SECTION_NUM; ++k)
|
for (m = 0; m < CHANNEL_MAX_NUMBER_2G; ++m)
|
for (l = 0; l < MAX_RF_PATH_NUM; ++l)
|
pHalData->TxPwrLimit_2_4G[i][j][k][m][l] = MAX_POWER_INDEX;
|
}
|
|
for (i = 0; i < MAX_REGULATION_NUM; ++i) {
|
for (j = 0; j < MAX_5G_BANDWIDTH_NUM; ++j)
|
for (k = 0; k < MAX_RATE_SECTION_NUM; ++k)
|
for (m = 0; m < CHANNEL_MAX_NUMBER_5G; ++m)
|
for (l = 0; l < MAX_RF_PATH_NUM; ++l)
|
pHalData->TxPwrLimit_5G[i][j][k][m][l] = MAX_POWER_INDEX;
|
}
|
|
/* DBG_871X("<===== PHY_InitTxPowerLimit()!\n"); */
|
}
|
|
void PHY_SetTxPowerLimit(
|
struct adapter *Adapter,
|
u8 *Regulation,
|
u8 *Band,
|
u8 *Bandwidth,
|
u8 *RateSection,
|
u8 *RfPath,
|
u8 *Channel,
|
u8 *PowerLimit
|
)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
u8 regulation = 0, bandwidth = 0, rateSection = 0, channel;
|
s8 powerLimit = 0, prevPowerLimit, channelIndex;
|
|
/* DBG_871X("Index of power limit table [band %s][regulation %s][bw %s][rate section %s][rf path %s][chnl %s][val %s]\n", */
|
/* Band, Regulation, Bandwidth, RateSection, RfPath, Channel, PowerLimit); */
|
|
if (!GetU1ByteIntegerFromStringInDecimal((s8 *)Channel, &channel) ||
|
!GetU1ByteIntegerFromStringInDecimal((s8 *)PowerLimit, &powerLimit))
|
DBG_871X("Illegal index of power limit table [chnl %s][val %s]\n", Channel, PowerLimit);
|
|
powerLimit = powerLimit > MAX_POWER_INDEX ? MAX_POWER_INDEX : powerLimit;
|
|
if (eqNByte(Regulation, (u8 *)("FCC"), 3))
|
regulation = 0;
|
else if (eqNByte(Regulation, (u8 *)("MKK"), 3))
|
regulation = 1;
|
else if (eqNByte(Regulation, (u8 *)("ETSI"), 4))
|
regulation = 2;
|
else if (eqNByte(Regulation, (u8 *)("WW13"), 4))
|
regulation = 3;
|
|
if (eqNByte(RateSection, (u8 *)("CCK"), 3) && eqNByte(RfPath, (u8 *)("1T"), 2))
|
rateSection = 0;
|
else if (eqNByte(RateSection, (u8 *)("OFDM"), 4) && eqNByte(RfPath, (u8 *)("1T"), 2))
|
rateSection = 1;
|
else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("1T"), 2))
|
rateSection = 2;
|
else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("2T"), 2))
|
rateSection = 3;
|
else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("3T"), 2))
|
rateSection = 4;
|
else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("4T"), 2))
|
rateSection = 5;
|
else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("1T"), 2))
|
rateSection = 6;
|
else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("2T"), 2))
|
rateSection = 7;
|
else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("3T"), 2))
|
rateSection = 8;
|
else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("4T"), 2))
|
rateSection = 9;
|
else {
|
DBG_871X("Wrong rate section!\n");
|
return;
|
}
|
|
|
if (eqNByte(Bandwidth, (u8 *)("20M"), 3))
|
bandwidth = 0;
|
else if (eqNByte(Bandwidth, (u8 *)("40M"), 3))
|
bandwidth = 1;
|
else if (eqNByte(Bandwidth, (u8 *)("80M"), 3))
|
bandwidth = 2;
|
else if (eqNByte(Bandwidth, (u8 *)("160M"), 4))
|
bandwidth = 3;
|
|
if (eqNByte(Band, (u8 *)("2.4G"), 4)) {
|
channelIndex = phy_GetChannelIndexOfTxPowerLimit(BAND_ON_2_4G, channel);
|
|
if (channelIndex == -1)
|
return;
|
|
prevPowerLimit = pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A];
|
|
if (powerLimit < prevPowerLimit)
|
pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] = powerLimit;
|
|
/* DBG_871X("2.4G Band value : [regulation %d][bw %d][rate_section %d][chnl %d][val %d]\n", */
|
/* regulation, bandwidth, rateSection, channelIndex, pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A]); */
|
} else if (eqNByte(Band, (u8 *)("5G"), 2)) {
|
channelIndex = phy_GetChannelIndexOfTxPowerLimit(BAND_ON_5G, channel);
|
|
if (channelIndex == -1)
|
return;
|
|
prevPowerLimit = pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A];
|
|
if (powerLimit < prevPowerLimit)
|
pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] = powerLimit;
|
|
/* DBG_871X("5G Band value : [regulation %d][bw %d][rate_section %d][chnl %d][val %d]\n", */
|
/* regulation, bandwidth, rateSection, channel, pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A]); */
|
} else {
|
DBG_871X("Cannot recognize the band info in %s\n", Band);
|
return;
|
}
|
}
|
|
void Hal_ChannelPlanToRegulation(struct adapter *Adapter, u16 ChannelPlan)
|
{
|
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
|
pHalData->Regulation2_4G = TXPWR_LMT_WW;
|
pHalData->Regulation5G = TXPWR_LMT_WW;
|
|
switch (ChannelPlan) {
|
case RT_CHANNEL_DOMAIN_WORLD_NULL:
|
pHalData->Regulation2_4G = TXPWR_LMT_WW;
|
break;
|
case RT_CHANNEL_DOMAIN_ETSI1_NULL:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_NULL:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_MKK1_NULL:
|
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
|
break;
|
case RT_CHANNEL_DOMAIN_ETSI2_NULL:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_FCC1:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI1:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_MKK1_MKK1:
|
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
|
pHalData->Regulation5G = TXPWR_LMT_MKK;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_KCC1:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_MKK;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_FCC2:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_FCC3:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_FCC4:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_FCC5:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_FCC6:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_FCC7:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI2:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI3:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_MKK1_MKK2:
|
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_MKK1_MKK3:
|
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_NCC1:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_NCC2:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_GLOBAL_NULL:
|
pHalData->Regulation2_4G = TXPWR_LMT_WW;
|
pHalData->Regulation5G = TXPWR_LMT_WW;
|
break;
|
case RT_CHANNEL_DOMAIN_ETSI1_ETSI4:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_FCC2:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_NCC3:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI5:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_FCC8:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI6:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI7:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI8:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI9:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI10:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI11:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_NCC4:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI12:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_FCC9:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_WORLD_ETSI13:
|
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
|
pHalData->Regulation5G = TXPWR_LMT_ETSI;
|
break;
|
case RT_CHANNEL_DOMAIN_FCC1_FCC10:
|
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
|
pHalData->Regulation5G = TXPWR_LMT_FCC;
|
break;
|
case RT_CHANNEL_DOMAIN_REALTEK_DEFINE: /* Realtek Reserve */
|
pHalData->Regulation2_4G = TXPWR_LMT_WW;
|
pHalData->Regulation5G = TXPWR_LMT_WW;
|
break;
|
default:
|
break;
|
}
|
}
|
