drivers/net/wireless/rtl8723bs/hal/hal_com_phycfg.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _HAL_COM_PHYCFG_C_
  21
  22 #include <drv_types.h>
  23 #include <hal_data.h>
  24
  25
  26 //
  27 //      Description:
  28 //              Map Tx power index into dBm according to
  29 //              current HW model, for example, RF and PA, and
  30 //              current wireless mode.
  31 //      By Bruce, 2008-01-29.
  32 //
  33 s32
  34 phy_TxPwrIdxToDbm(
  35         IN      PADAPTER                Adapter,
  36         IN      WIRELESS_MODE   WirelessMode,
  37         IN      u8                              TxPwrIdx
  38         )
  39 {
  40         s32                             Offset = 0;
  41         s32                             PwrOutDbm = 0;
  42
  43         //
  44         // Tested by MP, we found that CCK Index 0 equals to -7dbm, OFDM legacy equals to -8dbm.
  45         // Note:
  46         //      The mapping may be different by different NICs. Do not use this formula for what needs accurate result.
  47         // By Bruce, 2008-01-29.
  48         //
  49         switch(WirelessMode)
  50         {
  51         case WIRELESS_MODE_B:
  52                 Offset = -7;
  53                 break;
  54
  55         case WIRELESS_MODE_G:
  56         case WIRELESS_MODE_N_24G:
  57                 Offset = -8;
  58                 break;
  59
  60         default: //for MacOSX compiler warning
  61                 break;
  62         }
  63
  64         PwrOutDbm = TxPwrIdx / 2 + Offset; // Discard the decimal part.
  65
  66         return PwrOutDbm;
  67 }
  68
  69 u8
  70 PHY_GetTxPowerByRateBase(
  71         IN      PADAPTER                Adapter,
  72         IN      u8                              Band,
  73         IN      u8                              RfPath,
  74         IN      u8                              TxNum,
  75         IN      RATE_SECTION    RateSection
  76         )
  77 {
  78         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
  79         u8                      value = 0;
  80
  81         if ( RfPath > ODM_RF_PATH_D )
  82         {
  83                 DBG_871X("Invalid Rf Path %d in PHY_GetTxPowerByRateBase()\n", RfPath );
  84                 return 0;
  85         }
  86
  87         if ( Band == BAND_ON_2_4G )
  88         {
  89                 switch ( RateSection ) {
  90                         case CCK:
  91                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][0];
  92                                 break;
  93                         case OFDM:
  94                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][1];
  95                                 break;
  96                         case HT_MCS0_MCS7:
  97                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][2];
  98                                 break;
  99                         case HT_MCS8_MCS15:
 100                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][3];
 101                                 break;
 102                         case HT_MCS16_MCS23:
 103                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][4];
 104                                 break;
 105                         case HT_MCS24_MCS31:
 106                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][5];
 107                                 break;
 108                         case VHT_1SSMCS0_1SSMCS9:
 109                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][6];
 110                                 break;
 111                         case VHT_2SSMCS0_2SSMCS9:
 112                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][7];
 113                                 break;
 114                         case VHT_3SSMCS0_3SSMCS9:
 115                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][8];
 116                                 break;
 117                         case VHT_4SSMCS0_4SSMCS9:
 118                                 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][9];
 119                                 break;
 120                         default:
 121                                 DBG_871X("Invalid RateSection %d in Band 2.4G, Rf Path %d, %dTx in PHY_GetTxPowerByRateBase()\n",
 122                                                  RateSection, RfPath, TxNum );
 123                                 break;
 124
 125                 };
 126         }
 127         else if ( Band == BAND_ON_5G )
 128         {
 129                 switch ( RateSection ) {
 130                         case OFDM:
 131                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][0];
 132                                 break;
 133                         case HT_MCS0_MCS7:
 134                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][1];
 135                                 break;
 136                         case HT_MCS8_MCS15:
 137                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][2];
 138                                 break;
 139                         case HT_MCS16_MCS23:
 140                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][3];
 141                                 break;
 142                         case HT_MCS24_MCS31:
 143                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][4];
 144                                 break;
 145                         case VHT_1SSMCS0_1SSMCS9:
 146                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][5];
 147                                 break;
 148                         case VHT_2SSMCS0_2SSMCS9:
 149                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][6];
 150                                 break;
 151                         case VHT_3SSMCS0_3SSMCS9:
 152                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][7];
 153                                 break;
 154                         case VHT_4SSMCS0_4SSMCS9:
 155                                 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][8];
 156                                 break;
 157                         default:
 158                                 DBG_871X("Invalid RateSection %d in Band 5G, Rf Path %d, %dTx in PHY_GetTxPowerByRateBase()\n",
 159                                                  RateSection, RfPath, TxNum );
 160                                 break;
 161                 };
 162         }
 163         else
 164         {
 165                 DBG_871X("Invalid Band %d in PHY_GetTxPowerByRateBase()\n", Band );
 166         }
 167
 168         return value;
 169 }
 170
 171 VOID
 172 phy_SetTxPowerByRateBase(
 173         IN      PADAPTER                Adapter,
 174         IN      u8                              Band,
 175         IN      u8                              RfPath,
 176         IN      RATE_SECTION    RateSection,
 177         IN      u8                              TxNum,
 178         IN      u8                              Value
 179         )
 180 {
 181         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
 182
 183         if ( RfPath > ODM_RF_PATH_D )
 184         {
 185                 DBG_871X("Invalid Rf Path %d in phy_SetTxPowerByRatBase()\n", RfPath );
 186                 return;
 187         }
 188
 189         if ( Band == BAND_ON_2_4G )
 190         {
 191                 switch ( RateSection ) {
 192                         case CCK:
 193                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][0] = Value;
 194                                 break;
 195                         case OFDM:
 196                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][1] = Value;
 197                                 break;
 198                         case HT_MCS0_MCS7:
 199                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][2] = Value;
 200                                 break;
 201                         case HT_MCS8_MCS15:
 202                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][3] = Value;
 203                                 break;
 204                         case HT_MCS16_MCS23:
 205                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][4] = Value;
 206                                 break;
 207                         case HT_MCS24_MCS31:
 208                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][5] = Value;
 209                                 break;
 210                         case VHT_1SSMCS0_1SSMCS9:
 211                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][6] = Value;
 212                                 break;
 213                         case VHT_2SSMCS0_2SSMCS9:
 214                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][7] = Value;
 215                                 break;
 216                         case VHT_3SSMCS0_3SSMCS9:
 217                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][8] = Value;
 218                                 break;
 219                         case VHT_4SSMCS0_4SSMCS9:
 220                                 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][9] = Value;
 221                                 break;
 222                         default:
 223                                 DBG_871X("Invalid RateSection %d in Band 2.4G, Rf Path %d, %dTx in phy_SetTxPowerByRateBase()\n",
 224                                                  RateSection, RfPath, TxNum );
 225                                 break;
 226                 };
 227         }
 228         else if ( Band == BAND_ON_5G )
 229         {
 230                 switch ( RateSection ) {
 231                         case OFDM:
 232                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][0] = Value;
 233                                 break;
 234                         case HT_MCS0_MCS7:
 235                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][1] = Value;
 236                                 break;
 237                         case HT_MCS8_MCS15:
 238                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][2] = Value;
 239                                 break;
 240                         case HT_MCS16_MCS23:
 241                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][3] = Value;
 242                                 break;
 243                         case HT_MCS24_MCS31:
 244                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][4] = Value;
 245                                 break;
 246                         case VHT_1SSMCS0_1SSMCS9:
 247                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][5] = Value;
 248                                 break;
 249                         case VHT_2SSMCS0_2SSMCS9:
 250                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][6] = Value;
 251                                 break;
 252                         case VHT_3SSMCS0_3SSMCS9:
 253                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][7] = Value;
 254                                 break;
 255                         case VHT_4SSMCS0_4SSMCS9:
 256                                 pHalData->TxPwrByRateBase5G[RfPath][TxNum][8] = Value;
 257                                 break;
 258                         default:
 259                                 DBG_871X("Invalid RateSection %d in Band 5G, Rf Path %d, %dTx in phy_SetTxPowerByRateBase()\n",
 260                                                  RateSection, RfPath, TxNum );
 261                                 break;
 262                 };
 263         }
 264         else
 265         {
 266                 DBG_871X("Invalid Band %d in phy_SetTxPowerByRateBase()\n", Band );
 267         }
 268 }
 269
 270 VOID
 271 phy_StoreTxPowerByRateBaseOld(
 272         IN      PADAPTER        pAdapter
 273         )
 274 {
 275         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
 276         u16                     rawValue = 0;
 277         u8                      base = 0;
 278         u8                      path = 0;
 279
 280         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][7] >> 8 ) & 0xFF;
 281         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 282         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, CCK, RF_1TX, base );
 283
 284         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][1] >> 24 ) & 0xFF;
 285         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 286         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, OFDM, RF_1TX, base );
 287
 288         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][3] >> 24 ) & 0xFF;
 289         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 290         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, HT_MCS0_MCS7, RF_1TX, base );
 291
 292         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][5] >> 24 ) & 0xFF;
 293         base = ( rawValue >> 4) * 10 + ( rawValue & 0xF );
 294         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, HT_MCS8_MCS15, RF_2TX, base );
 295
 296         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][7] & 0xFF );
 297         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 298         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, CCK, RF_1TX, base );
 299
 300         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][9] >> 24 ) & 0xFF;
 301         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 302         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, OFDM, RF_1TX, base );
 303
 304         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][11] >> 24 ) & 0xFF;
 305         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 306         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, HT_MCS0_MCS7, RF_1TX, base );
 307
 308         rawValue = ( u16 ) ( pHalData->MCSTxPowerLevelOriginalOffset[0][13] >> 24 ) & 0xFF;
 309         base = ( rawValue >> 4 ) * 10 + ( rawValue & 0xF );
 310         phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, HT_MCS8_MCS15, RF_2TX, base );
 311 }
 312
 313 VOID
 314 phy_StoreTxPowerByRateBase(
 315         IN      PADAPTER        pAdapter
 316         )
 317 {
 318         u8      path = 0, base = 0, index = 0;
 319
 320         //DBG_871X( "===>%s\n", __FUNCTION__ );
 321
 322         for ( path = ODM_RF_PATH_A; path <= ODM_RF_PATH_B; ++path )
 323         {
 324                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_1TX, MGN_11M );
 325                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, CCK, RF_1TX, base );
 326                 //DBG_871X("Power index base of 2.4G path %d 1Tx CCK = > 0x%x\n", path, base );
 327
 328                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_1TX, MGN_54M );
 329                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, OFDM, RF_1TX, base );
 330                 //DBG_871X("Power index base of 2.4G path %d 1Tx OFDM = > 0x%x\n", path, base );
 331
 332                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_1TX, MGN_MCS7 );
 333                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, HT_MCS0_MCS7, RF_1TX, base );
 334                 //DBG_871X("Power index base of 2.4G path %d 1Tx MCS0-7 = > 0x%x\n", path, base );
 335
 336                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_2TX, MGN_MCS15 );
 337                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, HT_MCS8_MCS15, RF_2TX, base );
 338                 //DBG_871X("Power index base of 2.4G path %d 2Tx MCS8-15 = > 0x%x\n", path, base );
 339
 340                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_3TX, MGN_MCS23 );
 341                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, HT_MCS16_MCS23, RF_3TX, base );
 342                 //DBG_871X("Power index base of 2.4G path %d 3Tx MCS16-23 = > 0x%x\n", path, base );
 343
 344                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_1TX, MGN_VHT1SS_MCS7 );
 345                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, VHT_1SSMCS0_1SSMCS9, RF_1TX, base );
 346                 //DBG_871X("Power index base of 2.4G path %d 1Tx VHT1SS = > 0x%x\n", path, base );
 347
 348                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_2TX, MGN_VHT2SS_MCS7 );
 349                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, VHT_2SSMCS0_2SSMCS9, RF_2TX, base );
 350                 //DBG_871X("Power index base of 2.4G path %d 2Tx VHT2SS = > 0x%x\n", path, base );
 351
 352                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_2_4G, path, RF_3TX, MGN_VHT3SS_MCS7 );
 353                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, path, VHT_3SSMCS0_3SSMCS9, RF_3TX, base );
 354                 //DBG_871X("Power index base of 2.4G path %d 3Tx VHT3SS = > 0x%x\n", path, base );
 355
 356                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_1TX, MGN_54M );
 357                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, OFDM, RF_1TX, base );
 358                 //DBG_871X("Power index base of 5G path %d 1Tx OFDM = > 0x%x\n", path, base );
 359
 360                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_1TX, MGN_MCS7 );
 361                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, HT_MCS0_MCS7, RF_1TX, base );
 362                 //DBG_871X("Power index base of 5G path %d 1Tx MCS0~7 = > 0x%x\n", path, base );
 363
 364                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_2TX, MGN_MCS15 );
 365                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, HT_MCS8_MCS15, RF_2TX, base );
 366                 //DBG_871X("Power index base of 5G path %d 2Tx MCS8~15 = > 0x%x\n", path, base );
 367
 368                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_3TX, MGN_MCS23 );
 369                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, HT_MCS16_MCS23, RF_3TX, base );
 370                 //DBG_871X("Power index base of 5G path %d 3Tx MCS16~23 = > 0x%x\n", path, base );
 371
 372                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_1TX, MGN_VHT1SS_MCS7 );
 373                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, VHT_1SSMCS0_1SSMCS9, RF_1TX, base );
 374                 //DBG_871X("Power index base of 5G path %d 1Tx VHT1SS = > 0x%x\n", path, base );
 375
 376                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_2TX, MGN_VHT2SS_MCS7 );
 377                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, VHT_2SSMCS0_2SSMCS9, RF_2TX, base );
 378                 //DBG_871X("Power index base of 5G path %d 2Tx VHT2SS = > 0x%x\n", path, base );
 379
 380                 base = PHY_GetTxPowerByRate( pAdapter, BAND_ON_5G, path, RF_3TX, MGN_VHT2SS_MCS7 );
 381                 phy_SetTxPowerByRateBase( pAdapter, BAND_ON_5G, path, VHT_3SSMCS0_3SSMCS9, RF_3TX, base );
 382                 //DBG_871X("Power index base of 5G path %d 3Tx VHT3SS = > 0x%x\n", path, base );
 383         }
 384
 385         //DBG_871X("<===%s\n", __FUNCTION__ );
 386 }
 387
 388 u8
 389 PHY_GetRateSectionIndexOfTxPowerByRate(
 390         IN      PADAPTER        pAdapter,
 391         IN      u32                     RegAddr,
 392         IN      u32                     BitMask
 393         )
 394 {
 395         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
 396         PDM_ODM_T               pDM_Odm = &pHalData->odmpriv;
 397         u8                      index = 0;
 398
 399         if ( pDM_Odm->PhyRegPgVersion == 0 )
 400         {
 401                 switch ( RegAddr )
 402                 {
 403                         case rTxAGC_A_Rate18_06:         index = 0;             break;
 404                         case rTxAGC_A_Rate54_24:         index = 1;             break;
 405                         case rTxAGC_A_CCK1_Mcs32:        index = 6;             break;
 406                         case rTxAGC_B_CCK11_A_CCK2_11:
 407                                 if ( BitMask == 0xffffff00 )
 408                                         index = 7;
 409                                 else if ( BitMask == 0x000000ff )
 410                                         index = 15;
 411                                 break;
 412
 413                         case rTxAGC_A_Mcs03_Mcs00:       index = 2;             break;
 414                         case rTxAGC_A_Mcs07_Mcs04:       index = 3;             break;
 415                         case rTxAGC_A_Mcs11_Mcs08:       index = 4;             break;
 416                         case rTxAGC_A_Mcs15_Mcs12:       index = 5;             break;
 417                         case rTxAGC_B_Rate18_06:         index = 8;             break;
 418                         case rTxAGC_B_Rate54_24:         index = 9;             break;
 419                         case rTxAGC_B_CCK1_55_Mcs32: index = 14;        break;
 420                         case rTxAGC_B_Mcs03_Mcs00:       index = 10;    break;
 421                         case rTxAGC_B_Mcs07_Mcs04:       index = 11;    break;
 422                         case rTxAGC_B_Mcs11_Mcs08:       index = 12;    break;
 423                         case rTxAGC_B_Mcs15_Mcs12:       index = 13;    break;
 424                         default:
 425                                 DBG_871X("Invalid RegAddr 0x3%x in PHY_GetRateSectionIndexOfTxPowerByRate()", RegAddr );
 426                                 break;
 427                 };
 428         }
 429
 430         return index;
 431 }
 432
 433 VOID
 434 PHY_GetRateValuesOfTxPowerByRate(
 435         IN      PADAPTER        pAdapter,
 436         IN      u32                     RegAddr,
 437         IN      u32                     BitMask,
 438         IN      u32                     Value,
 439         OUT     u8*                     RateIndex,
 440         OUT     s8*                     PwrByRateVal,
 441         OUT     u8*                     RateNum
 442         )
 443 {
 444         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
 445         PDM_ODM_T               pDM_Odm = &pHalData->odmpriv;
 446         u8                              index = 0, i = 0;
 447
 448         switch ( RegAddr )
 449         {
 450                 case rTxAGC_A_Rate18_06:
 451                 case rTxAGC_B_Rate18_06:
 452                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_6M );
 453                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_9M );
 454                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_12M );
 455                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_18M );
 456                         for ( i = 0; i < 4; ++ i )
 457                         {
 458                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 459                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 460                         }
 461                         *RateNum = 4;
 462                         break;
 463
 464                 case rTxAGC_A_Rate54_24:
 465                 case rTxAGC_B_Rate54_24:
 466                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_24M );
 467                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_36M );
 468                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_48M );
 469                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_54M );
 470                         for ( i = 0; i < 4; ++ i )
 471                         {
 472                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 473                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 474                         }
 475                         *RateNum = 4;
 476                         break;
 477
 478                 case rTxAGC_A_CCK1_Mcs32:
 479                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_1M );
 480                         PwrByRateVal[0] = ( s8 ) ( ( ( ( Value >> (8 + 4) ) & 0xF ) ) * 10 +
 481                                                                                         ( ( Value >> 8 ) & 0xF ) );
 482                         *RateNum = 1;
 483                         break;
 484
 485                 case rTxAGC_B_CCK11_A_CCK2_11:
 486                         if ( BitMask == 0xffffff00 )
 487                         {
 488                                 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_2M );
 489                                 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_5_5M );
 490                                 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_11M );
 491                                 for ( i = 1; i < 4; ++ i )
 492                                 {
 493                                         PwrByRateVal[i - 1] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 494                                                                                                         ( ( Value >> (i * 8) ) & 0xF ) );
 495                                 }
 496                                 *RateNum = 3;
 497                         }
 498                         else if ( BitMask == 0x000000ff )
 499                         {
 500                                 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_11M );
 501                                 PwrByRateVal[0] = ( s8 ) ( ( ( ( Value >> 4 ) & 0xF ) ) * 10 +
 502                                                                                                 ( Value & 0xF ) );
 503                                 *RateNum = 1;
 504                         }
 505                         break;
 506
 507                 case rTxAGC_A_Mcs03_Mcs00:
 508                 case rTxAGC_B_Mcs03_Mcs00:
 509                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS0 );
 510                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS1 );
 511                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS2 );
 512                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS3 );
 513                         for ( i = 0; i < 4; ++ i )
 514                         {
 515                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 516                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 517                         }
 518                         *RateNum = 4;
 519                         break;
 520
 521                 case rTxAGC_A_Mcs07_Mcs04:
 522                 case rTxAGC_B_Mcs07_Mcs04:
 523                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS4 );
 524                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS5 );
 525                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS6 );
 526                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS7 );
 527                         for ( i = 0; i < 4; ++ i )
 528                         {
 529                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 530                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 531                         }
 532                         *RateNum = 4;
 533                         break;
 534
 535                 case rTxAGC_A_Mcs11_Mcs08:
 536                 case rTxAGC_B_Mcs11_Mcs08:
 537                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS8 );
 538                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS9 );
 539                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS10 );
 540                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS11 );
 541                         for ( i = 0; i < 4; ++ i )
 542                         {
 543                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 544                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 545                         }
 546                         *RateNum = 4;
 547                         break;
 548
 549                 case rTxAGC_A_Mcs15_Mcs12:
 550                 case rTxAGC_B_Mcs15_Mcs12:
 551                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS12 );
 552                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS13 );
 553                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS14 );
 554                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS15 );
 555                         for ( i = 0; i < 4; ++ i )
 556                         {
 557                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 558                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 559                         }
 560                         *RateNum = 4;
 561
 562                         break;
 563
 564                 case rTxAGC_B_CCK1_55_Mcs32:
 565                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_1M );
 566                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_2M );
 567                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_5_5M );
 568                         for ( i = 1; i < 4; ++ i )
 569                         {
 570                                 PwrByRateVal[i - 1] = ( s8 ) ( ( ( ( Value >> ( i * 8 + 4) ) & 0xF ) ) * 10 +
 571                                                                                                 ( ( Value >> ( i * 8) ) & 0xF ) );
 572                         }
 573                         *RateNum = 3;
 574                         break;
 575
 576                 case 0xC20:
 577                 case 0xE20:
 578                 case 0x1820:
 579                 case 0x1a20:
 580                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_1M );
 581                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_2M );
 582                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_5_5M );
 583                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_11M );
 584                         for ( i = 0; i < 4; ++ i )
 585                         {
 586                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 587                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 588                         }
 589                         *RateNum = 4;
 590                         break;
 591
 592                 case 0xC24:
 593                 case 0xE24:
 594                 case 0x1824:
 595                 case 0x1a24:
 596                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_6M );
 597                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_9M );
 598                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_12M );
 599                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_18M );
 600                         for ( i = 0; i < 4; ++ i )
 601                         {
 602                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 603                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 604                         }
 605                         *RateNum = 4;
 606                         break;
 607
 608                 case 0xC28:
 609                 case 0xE28:
 610                 case 0x1828:
 611                 case 0x1a28:
 612                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_24M );
 613                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_36M );
 614                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_48M );
 615                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_54M );
 616                         for ( i = 0; i < 4; ++ i )
 617                         {
 618                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 619                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 620                         }
 621                         *RateNum = 4;
 622                         break;
 623
 624                 case 0xC2C:
 625                 case 0xE2C:
 626                 case 0x182C:
 627                 case 0x1a2C:
 628                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS0 );
 629                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS1 );
 630                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS2 );
 631                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS3 );
 632                         for ( i = 0; i < 4; ++ i )
 633                         {
 634                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 635                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 636                         }
 637                         *RateNum = 4;
 638                         break;
 639
 640                 case 0xC30:
 641                 case 0xE30:
 642                 case 0x1830:
 643                 case 0x1a30:
 644                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS4 );
 645                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS5 );
 646                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS6 );
 647                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS7 );
 648                         for ( i = 0; i < 4; ++ i )
 649                         {
 650                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 651                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 652                         }
 653                         *RateNum = 4;
 654                         break;
 655
 656                 case 0xC34:
 657                 case 0xE34:
 658                 case 0x1834:
 659                 case 0x1a34:
 660                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS8 );
 661                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS9 );
 662                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS10 );
 663                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS11 );
 664                         for ( i = 0; i < 4; ++ i )
 665                         {
 666                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 667                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 668                         }
 669                         *RateNum = 4;
 670                         break;
 671
 672                 case 0xC38:
 673                 case 0xE38:
 674                 case 0x1838:
 675                 case 0x1a38:
 676                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS12 );
 677                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS13 );
 678                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS14 );
 679                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS15 );
 680                         for ( i = 0; i < 4; ++ i )
 681                         {
 682                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 683                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 684                         }
 685                         *RateNum = 4;
 686                         break;
 687
 688                 case 0xC3C:
 689                 case 0xE3C:
 690                 case 0x183C:
 691                 case 0x1a3C:
 692                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS0 );
 693                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS1 );
 694                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS2 );
 695                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS3 );
 696                         for ( i = 0; i < 4; ++ i )
 697                         {
 698                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 699                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 700                         }
 701                         *RateNum = 4;
 702                         break;
 703
 704                 case 0xC40:
 705                 case 0xE40:
 706                 case 0x1840:
 707                 case 0x1a40:
 708                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS4 );
 709                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS5 );
 710                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS6 );
 711                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS7 );
 712                         for ( i = 0; i < 4; ++ i )
 713                         {
 714                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 715                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 716                         }
 717                         *RateNum = 4;
 718                         break;
 719
 720                 case 0xC44:
 721                 case 0xE44:
 722                 case 0x1844:
 723                 case 0x1a44:
 724                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS8 );
 725                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT1SS_MCS9 );
 726                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS0 );
 727                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS1 );
 728                         for ( i = 0; i < 4; ++ i )
 729                         {
 730                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 731                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 732                         }
 733                         *RateNum = 4;
 734                         break;
 735
 736                 case 0xC48:
 737                 case 0xE48:
 738                 case 0x1848:
 739                 case 0x1a48:
 740                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS2 );
 741                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS3 );
 742                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS4 );
 743                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS5 );
 744                         for ( i = 0; i < 4; ++ i )
 745                         {
 746                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 747                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 748                         }
 749                         *RateNum = 4;
 750                         break;
 751
 752                 case 0xC4C:
 753                 case 0xE4C:
 754                 case 0x184C:
 755                 case 0x1a4C:
 756                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS6 );
 757                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS7 );
 758                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS8 );
 759                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS9 );
 760                         for ( i = 0; i < 4; ++ i )
 761                         {
 762                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 763                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 764                         }
 765                         *RateNum = 4;
 766                         break;
 767
 768                 case 0xCD8:
 769                 case 0xED8:
 770                 case 0x18D8:
 771                 case 0x1aD8:
 772                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS16 );
 773                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS17 );
 774                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS18 );
 775                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS19 );
 776                         for ( i = 0; i < 4; ++ i )
 777                         {
 778                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 779                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 780                         }
 781                         *RateNum = 4;
 782                         break;
 783
 784                 case 0xCDC:
 785                 case 0xEDC:
 786                 case 0x18DC:
 787                 case 0x1aDC:
 788                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS20 );
 789                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS21 );
 790                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS22 );
 791                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_MCS23 );
 792                         for ( i = 0; i < 4; ++ i )
 793                         {
 794                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 795                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 796                         }
 797                         *RateNum = 4;
 798                         break;
 799
 800                 case 0xCE0:
 801                 case 0xEE0:
 802                 case 0x18E0:
 803                 case 0x1aE0:
 804                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS0 );
 805                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS1 );
 806                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS2 );
 807                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS3 );
 808                         for ( i = 0; i < 4; ++ i )
 809                         {
 810                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 811                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 812                         }
 813                         *RateNum = 4;
 814                         break;
 815
 816                 case 0xCE4:
 817                 case 0xEE4:
 818                 case 0x18E4:
 819                 case 0x1aE4:
 820                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS4 );
 821                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS5 );
 822                         RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS6 );
 823                         RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS7 );
 824                         for ( i = 0; i < 4; ++ i )
 825                         {
 826                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 827                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 828                         }
 829                         *RateNum = 4;
 830                         break;
 831
 832                 case 0xCE8:
 833                 case 0xEE8:
 834                 case 0x18E8:
 835                 case 0x1aE8:
 836                         RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS8 );
 837                         RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate( MGN_VHT3SS_MCS9 );
 838                         for ( i = 0; i < 2; ++ i )
 839                         {
 840                                 PwrByRateVal[i] = ( s8 ) ( ( ( ( Value >> (i * 8 + 4) ) & 0xF ) ) * 10 +
 841                                                                                                 ( ( Value >> (i * 8) ) & 0xF ) );
 842                         }
 843                         *RateNum = 4;
 844                         break;
 845
 846                 default:
 847                         DBG_871X("Invalid RegAddr 0x%x in %s()\n", RegAddr, __FUNCTION__);
 848                         break;
 849         };
 850 }
 851
 852 void
 853 PHY_StoreTxPowerByRateNew(
 854         IN      PADAPTER        pAdapter,
 855         IN      u32                     Band,
 856         IN      u32                     RfPath,
 857         IN      u32                     TxNum,
 858         IN      u32                     RegAddr,
 859         IN      u32                     BitMask,
 860         IN      u32                     Data
 861         )
 862 {
 863         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(pAdapter);
 864         u8      i = 0, rateIndex[4] = {0}, rateNum = 0;
 865         s8      PwrByRateVal[4] = {0};
 866
 867         PHY_GetRateValuesOfTxPowerByRate( pAdapter, RegAddr, BitMask, Data, rateIndex, PwrByRateVal, &rateNum );
 868
 869         if ( Band != BAND_ON_2_4G && Band != BAND_ON_5G )
 870         {
 871                 DBG_871X("Invalid Band %d\n", Band );
 872                 return;
 873         }
 874
 875         if ( RfPath > ODM_RF_PATH_D )
 876         {
 877                 DBG_871X("Invalid RfPath %d\n", RfPath );
 878                 return;
 879         }
 880
 881         if ( TxNum > ODM_RF_PATH_D )
 882         {
 883                 DBG_871X("Invalid TxNum %d\n", TxNum );
 884                 return;
 885         }
 886
 887         for ( i = 0; i < rateNum; ++i )
 888         {
 889                 if ( rateIndex[i] == PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS0) ||
 890                          rateIndex[i] == PHY_GetRateIndexOfTxPowerByRate( MGN_VHT2SS_MCS1) )
 891                 {
 892                         TxNum = RF_2TX;
 893                 }
 894
 895                 pHalData->TxPwrByRateOffset[Band][RfPath][TxNum][rateIndex[i]] = PwrByRateVal[i];
 896         }
 897 }
 898
 899 void
 900 PHY_StoreTxPowerByRateOld(
 901         IN      PADAPTER                pAdapter,
 902         IN      u32                             RegAddr,
 903         IN      u32                             BitMask,
 904         IN      u32                             Data
 905         )
 906 {
 907         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 908         u8                      index = PHY_GetRateSectionIndexOfTxPowerByRate( pAdapter, RegAddr, BitMask );
 909
 910         pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][index] = Data;
 911         //DBG_871X("MCSTxPowerLevelOriginalOffset[%d][0] = 0x%x\n", pHalData->pwrGroupCnt,
 912         //      pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][0]);
 913 }
 914
 915 VOID
 916 PHY_InitTxPowerByRate(
 917         IN      PADAPTER        pAdapter
 918         )
 919 {
 920         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 921         u8      band = 0, rfPath = 0, TxNum = 0, rate = 0, i = 0, j = 0;
 922
 923         if ( IS_HARDWARE_TYPE_8188E( pAdapter ) || IS_HARDWARE_TYPE_8723A( pAdapter ) )
 924         {
 925                 for ( i = 0; i < MAX_PG_GROUP; ++i )
 926                         for ( j = 0; j < 16; ++j )
 927                                 pHalData->MCSTxPowerLevelOriginalOffset[i][j] = 0;
 928         }
 929         else
 930         {
 931                 for ( band = BAND_ON_2_4G; band <= BAND_ON_5G; ++band )
 932                                 for ( rfPath = 0; rfPath < TX_PWR_BY_RATE_NUM_RF; ++rfPath )
 933                                         for ( TxNum = 0; TxNum < TX_PWR_BY_RATE_NUM_RF; ++TxNum )
 934                                                 for ( rate = 0; rate < TX_PWR_BY_RATE_NUM_RATE; ++rate )
 935                                                         pHalData->TxPwrByRateOffset[band][rfPath][TxNum][rate] = 0;
 936         }
 937 }
 938
 939 VOID
 940 PHY_StoreTxPowerByRate(
 941         IN      PADAPTER        pAdapter,
 942         IN      u32                     Band,
 943         IN      u32                     RfPath,
 944         IN      u32                     TxNum,
 945         IN      u32                     RegAddr,
 946         IN      u32                     BitMask,
 947         IN      u32                     Data
 948         )
 949 {
 950         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 951         PDM_ODM_T               pDM_Odm = &pHalData->odmpriv;
 952
 953         if ( pDM_Odm->PhyRegPgVersion > 0 )
 954         {
 955                 PHY_StoreTxPowerByRateNew( pAdapter, Band, RfPath, TxNum, RegAddr, BitMask, Data );
 956         }
 957         else if ( pDM_Odm->PhyRegPgVersion == 0 )
 958         {
 959                 PHY_StoreTxPowerByRateOld( pAdapter, RegAddr, BitMask, Data );
 960
 961                 if ( RegAddr == rTxAGC_A_Mcs15_Mcs12 && pHalData->rf_type == RF_1T1R )
 962                         pHalData->pwrGroupCnt++;
 963                 else if ( RegAddr == rTxAGC_B_Mcs15_Mcs12 && pHalData->rf_type != RF_1T1R )
 964                         pHalData->pwrGroupCnt++;
 965         }
 966         else
 967                 DBG_871X("Invalid PHY_REG_PG.txt version %d\n",  pDM_Odm->PhyRegPgVersion );
 968
 969 }
 970
 971 VOID
 972 phy_ConvertTxPowerByRateByBase(
 973         IN      u32*            pData,
 974         IN      u8                      Start,
 975         IN      u8                      End,
 976         IN      u8                      BaseValue
 977         )
 978 {
 979         s8      i = 0;
 980         u8      TempValue = 0;
 981         u32     TempData = 0;
 982
 983         for ( i = 3; i >= 0; --i )
 984         {
 985                 if ( i >= Start && i <= End )
 986                 {
 987                         // Get the exact value
 988                         TempValue = ( u8 ) ( *pData >> ( i * 8 ) ) & 0xF;
 989                         TempValue += ( ( u8 ) ( ( *pData >> ( i * 8 + 4 ) ) & 0xF ) ) * 10;
 990
 991                         // Change the value to a relative value
 992                         TempValue = ( TempValue > BaseValue ) ? TempValue - BaseValue : BaseValue - TempValue;
 993                 }
 994                 else
 995                 {
 996                         TempValue = ( u8 ) ( *pData >> ( i * 8 ) ) & 0xFF;
 997                 }
 998
 999                 TempData <<= 8;
1000                 TempData |= TempValue;
1001         }
1002
1003         *pData = TempData;
1004 }
1005
1006
1007 VOID
1008 PHY_ConvertTxPowerByRateInDbmToRelativeValuesOld(
1009         IN      PADAPTER        pAdapter
1010         )
1011 {
1012         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
1013         u8                      base = 0;
1014
1015         //DBG_871X("===>PHY_ConvertTxPowerByRateInDbmToRelativeValuesOld()\n" );
1016
1017         // CCK
1018         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, RF_1TX, CCK );
1019         phy_ConvertTxPowerByRateByBase(
1020                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][6] ), 1, 1, base );
1021         phy_ConvertTxPowerByRateByBase(
1022                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][7] ), 1, 3, base );
1023
1024         // OFDM
1025         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, RF_1TX, OFDM );
1026         phy_ConvertTxPowerByRateByBase(
1027                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][0] ), 0, 3, base );
1028         phy_ConvertTxPowerByRateByBase(
1029                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][1] ),     0, 3, base );
1030
1031         // HT MCS0~7
1032         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, RF_1TX, HT_MCS0_MCS7 );
1033         phy_ConvertTxPowerByRateByBase(
1034                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][2] ),     0, 3, base );
1035         phy_ConvertTxPowerByRateByBase(
1036                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][3] ),     0, 3, base );
1037
1038         // HT MCS8~15
1039         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_A, RF_2TX, HT_MCS8_MCS15 );
1040         phy_ConvertTxPowerByRateByBase(
1041                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][4] ), 0, 3, base );
1042         phy_ConvertTxPowerByRateByBase(
1043                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][5] ), 0, 3, base );
1044
1045         // CCK
1046         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, RF_1TX, CCK );
1047         phy_ConvertTxPowerByRateByBase(
1048                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][14] ), 1, 3, base );
1049         phy_ConvertTxPowerByRateByBase(
1050                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][15] ), 0, 0, base );
1051
1052         // OFDM
1053         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, RF_1TX, OFDM );
1054         phy_ConvertTxPowerByRateByBase(
1055                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][8] ), 0, 3, base );
1056         phy_ConvertTxPowerByRateByBase(
1057                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][9] ),     0, 3, base );
1058
1059         // HT MCS0~7
1060         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, RF_1TX, HT_MCS0_MCS7 );
1061         phy_ConvertTxPowerByRateByBase(
1062                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][10] ), 0, 3, base );
1063         phy_ConvertTxPowerByRateByBase(
1064                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][11] ), 0, 3, base );
1065
1066         // HT MCS8~15
1067         base = PHY_GetTxPowerByRateBase( pAdapter, BAND_ON_2_4G, ODM_RF_PATH_B, RF_2TX, HT_MCS8_MCS15 );
1068         phy_ConvertTxPowerByRateByBase(
1069                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][12] ), 0, 3, base );
1070         phy_ConvertTxPowerByRateByBase(
1071                         &( pHalData->MCSTxPowerLevelOriginalOffset[0][13] ), 0, 3, base );
1072
1073         //DBG_871X("<===PHY_ConvertTxPowerByRateInDbmToRelativeValuesOld()\n" );
1074 }
1075
1076 VOID
1077 phy_ConvertTxPowerByRateInDbmToRelativeValues(
1078         IN      PADAPTER        pAdapter
1079         )
1080 {
1081         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
1082         u8                      base = 0, i = 0, value = 0,
1083                                 band = 0, path = 0, txNum = 0, index = 0,
1084                                 startIndex = 0, endIndex = 0;
1085         u8                      cckRates[4] = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M},
1086                                 ofdmRates[8] = {MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M},
1087                                 mcs0_7Rates[8] = {MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7},
1088                                 mcs8_15Rates[8] = {MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15},
1089                                 mcs16_23Rates[8] = {MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23},
1090                                 vht1ssRates[10] = {MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4,
1091                                                            MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9},
1092                                 vht2ssRates[10] = {MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4,
1093                                                            MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9},
1094                                 vht3ssRates[10] = {MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4,
1095                                                                    MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9};
1096
1097         //DBG_871X("===>PHY_ConvertTxPowerByRateInDbmToRelativeValues()\n" );
1098
1099         for ( band = BAND_ON_2_4G; band <= BAND_ON_5G; ++band )
1100         {
1101                 for ( path = ODM_RF_PATH_A; path <= ODM_RF_PATH_D; ++path )
1102                 {
1103                         for ( txNum = RF_1TX; txNum < RF_MAX_TX_NUM; ++txNum )
1104                         {
1105                                 // CCK
1106                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_11M );
1107                                 for ( i = 0; i < sizeof( cckRates ); ++i )
1108                                 {
1109                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, cckRates[i] );
1110                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, cckRates[i], value - base );
1111                                 }
1112
1113                                 // OFDM
1114                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_54M );
1115                                 for ( i = 0; i < sizeof( ofdmRates ); ++i )
1116                                 {
1117                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, ofdmRates[i] );
1118                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, ofdmRates[i], value - base );
1119                                 }
1120
1121                                 // HT MCS0~7
1122                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_MCS7 );
1123                                 for ( i = 0; i < sizeof( mcs0_7Rates ); ++i )
1124                                 {
1125                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, mcs0_7Rates[i] );
1126                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, mcs0_7Rates[i], value - base );
1127                                 }
1128
1129                                 // HT MCS8~15
1130                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_MCS15 );
1131                                 for ( i = 0; i < sizeof( mcs8_15Rates ); ++i )
1132                                 {
1133                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, mcs8_15Rates[i] );
1134                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, mcs8_15Rates[i], value - base );
1135                                 }
1136
1137                                 // HT MCS16~23
1138                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_MCS23 );
1139                                 for ( i = 0; i < sizeof( mcs16_23Rates ); ++i )
1140                                 {
1141                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, mcs16_23Rates[i] );
1142                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, mcs16_23Rates[i], value - base );
1143                                 }
1144
1145                                 // VHT 1SS
1146                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_VHT1SS_MCS7 );
1147                                 for ( i = 0; i < sizeof( vht1ssRates ); ++i )
1148                                 {
1149                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, vht1ssRates[i] );
1150                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, vht1ssRates[i], value - base );
1151                                 }
1152
1153                                 // VHT 2SS
1154                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_VHT2SS_MCS7 );
1155                                 for ( i = 0; i < sizeof( vht2ssRates ); ++i )
1156                                 {
1157                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, vht2ssRates[i] );
1158                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, vht2ssRates[i], value - base );
1159                                 }
1160
1161                                 // VHT 3SS
1162                                 base = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, MGN_VHT3SS_MCS7 );
1163                                 for ( i = 0; i < sizeof( vht3ssRates ); ++i )
1164                                 {
1165                                         value = PHY_GetTxPowerByRate( pAdapter, band, path, txNum, vht3ssRates[i] );
1166                                         PHY_SetTxPowerByRate( pAdapter, band, path, txNum, vht3ssRates[i], value - base );
1167                                 }
1168                         }
1169                 }
1170         }
1171
1172         //DBG_871X("<===PHY_ConvertTxPowerByRateInDbmToRelativeValues()\n" );
1173 }
1174
1175 /*
1176   * This function must be called if the value in the PHY_REG_PG.txt(or header)
1177   * is exact dBm values
1178   */
1179 VOID
1180 PHY_TxPowerByRateConfiguration(
1181         IN  PADAPTER                    pAdapter
1182         )
1183 {
1184         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter);
1185
1186         phy_StoreTxPowerByRateBase( pAdapter );
1187         phy_ConvertTxPowerByRateInDbmToRelativeValues( pAdapter );
1188 }
1189
1190 VOID
1191 PHY_SetTxPowerIndexByRateSection(
1192         IN      PADAPTER                pAdapter,
1193         IN      u8                              RFPath,
1194         IN      u8                              Channel,
1195         IN      u8                              RateSection
1196         )
1197 {
1198         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(pAdapter);
1199
1200         if ( RateSection == CCK )
1201         {
1202                 u8      cckRates[]   = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M};
1203                 if ( pHalData->CurrentBandType == BAND_ON_2_4G )
1204                         PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1205                                                                           cckRates, sizeof(cckRates)/sizeof(u8) );
1206
1207         }
1208         else if ( RateSection == OFDM )
1209         {
1210                 u8      ofdmRates[]  = {MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M};
1211                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1212                                                                          ofdmRates, sizeof(ofdmRates)/sizeof(u8));
1213
1214         }
1215         else if ( RateSection == HT_MCS0_MCS7 )
1216         {
1217                 u8      htRates1T[]  = {MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7};
1218                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1219                                                                          htRates1T, sizeof(htRates1T)/sizeof(u8));
1220
1221         }
1222         else if ( RateSection == HT_MCS8_MCS15 )
1223         {
1224                 u8      htRates2T[]  = {MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15};
1225                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1226                                                                          htRates2T, sizeof(htRates2T)/sizeof(u8));
1227
1228         }
1229         else if ( RateSection == HT_MCS16_MCS23 )
1230         {
1231                 u1Byte  htRates3T[]  = {MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23};
1232                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1233                                                                          htRates3T, sizeof(htRates3T)/sizeof(u1Byte));
1234
1235         }
1236         else if ( RateSection == HT_MCS24_MCS31 )
1237         {
1238                 u1Byte  htRates4T[]  = {MGN_MCS24, MGN_MCS25, MGN_MCS26, MGN_MCS27, MGN_MCS28, MGN_MCS29, MGN_MCS30, MGN_MCS31};
1239                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1240                                                                          htRates4T, sizeof(htRates4T)/sizeof(u1Byte));
1241
1242         }
1243         else if ( RateSection == VHT_1SSMCS0_1SSMCS9 )
1244         {
1245                 u8      vhtRates1T[] = {MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4,
1246                                 MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9};
1247                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1248                                                                         vhtRates1T, sizeof(vhtRates1T)/sizeof(u8));
1249
1250         }
1251         else if ( RateSection == VHT_2SSMCS0_2SSMCS9 )
1252         {
1253                 u8      vhtRates2T[] = {MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4,
1254                                 MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9};
1255
1256                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1257                                                                   vhtRates2T, sizeof(vhtRates2T)/sizeof(u8));
1258         }
1259         else if ( RateSection == VHT_3SSMCS0_3SSMCS9 )
1260         {
1261                 u1Byte  vhtRates3T[] = {MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4,
1262                                 MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9};
1263
1264                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1265                                                                   vhtRates3T, sizeof(vhtRates3T)/sizeof(u1Byte));
1266         }
1267         else if ( RateSection == VHT_4SSMCS0_4SSMCS9 )
1268         {
1269                 u1Byte  vhtRates4T[] = {MGN_VHT4SS_MCS0, MGN_VHT4SS_MCS1, MGN_VHT4SS_MCS2, MGN_VHT4SS_MCS3, MGN_VHT4SS_MCS4,
1270                                 MGN_VHT4SS_MCS5, MGN_VHT4SS_MCS6, MGN_VHT4SS_MCS7, MGN_VHT4SS_MCS8, MGN_VHT4SS_MCS9};
1271
1272                 PHY_SetTxPowerIndexByRateArray( pAdapter, RFPath, pHalData->CurrentChannelBW, Channel,
1273                                                                   vhtRates4T, sizeof(vhtRates4T)/sizeof(u1Byte));
1274         }
1275         else
1276         {
1277                 DBG_871X("Invalid RateSection %d in %s", RateSection, __FUNCTION__ );
1278         }
1279 }
1280
1281 BOOLEAN
1282 phy_GetChnlIndex(
1283         IN      u8      Channel,
1284         OUT u8* ChannelIdx
1285         )
1286 {
1287         u8      channel5G[CHANNEL_MAX_NUMBER_5G] =
1288                                  {36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,100,102,104,106,108,110,112,
1289                                 114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,149,151,
1290                                 153,155,157,159,161,163,165,167,168,169,171,173,175,177};
1291         u8  i = 0;
1292         BOOLEAN bIn24G=_TRUE;
1293
1294         if(Channel <= 14)
1295         {
1296                 bIn24G=_TRUE;
1297                 *ChannelIdx = Channel -1;
1298         }
1299         else
1300         {
1301                 bIn24G = _FALSE;
1302
1303                 for (i = 0; i < sizeof(channel5G)/sizeof(u8); ++i)
1304                 {
1305                         if ( channel5G[i] == Channel) {
1306                                 *ChannelIdx = i;
1307                                 return bIn24G;
1308                         }
1309                 }
1310         }
1311
1312         return bIn24G;
1313 }
1314
1315 u8
1316 PHY_GetTxPowerIndexBase(
1317         IN      PADAPTER                pAdapter,
1318         IN      u8                              RFPath,
1319         IN      u8                              Rate,
1320         IN      CHANNEL_WIDTH   BandWidth,
1321         IN      u8                              Channel,
1322         OUT PBOOLEAN            bIn24G
1323         )
1324 {
1325         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(pAdapter);
1326         PDM_ODM_T                       pDM_Odm = &pHalData->odmpriv;
1327         u8                                      i = 0;  //default set to 1S
1328         u8                                      txPower = 0;
1329         u8                                      chnlIdx = (Channel-1);
1330
1331         if (HAL_IsLegalChannel(pAdapter, Channel) == _FALSE)
1332         {
1333                 chnlIdx = 0;
1334                 DBG_871X("Illegal channel!!\n");
1335         }
1336
1337         *bIn24G = phy_GetChnlIndex(Channel, &chnlIdx);
1338
1339         //DBG_871X("[%s] Channel Index: %d\n", (*bIn24G?"2.4G":"5G"), chnlIdx);
1340
1341         if (*bIn24G) //3 ============================== 2.4 G ==============================
1342         {
1343                 if ( IS_CCK_RATE(Rate) )
1344                 {
1345                         txPower = pHalData->Index24G_CCK_Base[RFPath][chnlIdx];
1346                 }
1347                 else if ( MGN_6M <= Rate )
1348                 {
1349                         txPower = pHalData->Index24G_BW40_Base[RFPath][chnlIdx];
1350                 }
1351                 else
1352                 {
1353                         DBG_871X("PHY_GetTxPowerIndexBase: INVALID Rate.\n");
1354                 }
1355
1356                 //DBG_871X("Base Tx power(RF-%c, Rate #%d, Channel Index %d) = 0x%X\n",
1357                 //              ((RFPath==0)?'A':'B'), Rate, chnlIdx, txPower);
1358
1359                 // OFDM-1T
1360                 if ( (MGN_6M <= Rate && Rate <= MGN_54M) && ! IS_CCK_RATE(Rate) )
1361                 {
1362                         txPower += pHalData->OFDM_24G_Diff[RFPath][TX_1S];
1363                         //DBG_871X("+PowerDiff 2.4G (RF-%c): (OFDM-1T) = (%d)\n", ((RFPath==0)?'A':'B'), pHalData->OFDM_24G_Diff[RFPath][TX_1S]);
1364                 }
1365                 // BW20-1S, BW20-2S
1366                 if (BandWidth == CHANNEL_WIDTH_20)
1367                 {
1368                         if ( (MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1369                                 txPower += pHalData->BW20_24G_Diff[RFPath][TX_1S];
1370                         if ( (MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1371                                 txPower += pHalData->BW20_24G_Diff[RFPath][TX_2S];
1372                         if ( (MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1373                                 txPower += pHalData->BW20_24G_Diff[RFPath][TX_3S];
1374                         if ( (MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1375                                 txPower += pHalData->BW20_24G_Diff[RFPath][TX_4S];
1376
1377                         //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'),
1378                         //      pHalData->BW20_24G_Diff[RFPath][TX_1S], pHalData->BW20_24G_Diff[RFPath][TX_2S],
1379                         //      pHalData->BW20_24G_Diff[RFPath][TX_3S], pHalData->BW20_24G_Diff[RFPath][TX_4S]);
1380                 }
1381                 // BW40-1S, BW40-2S
1382                 else if (BandWidth == CHANNEL_WIDTH_40)
1383                 {
1384                         if ( (MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1385                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
1386                         if ( (MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1387                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_2S];
1388                         if ( (MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1389                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_3S];
1390                         if ( (MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1391                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_4S];
1392
1393                         //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'),
1394                         //      pHalData->BW40_24G_Diff[RFPath][TX_1S], pHalData->BW40_24G_Diff[RFPath][TX_2S],
1395                         //      pHalData->BW40_24G_Diff[RFPath][TX_3S], pHalData->BW40_24G_Diff[RFPath][TX_4S]);
1396                 }
1397                 // Willis suggest adopt BW 40M power index while in BW 80 mode
1398                 else if ( BandWidth == CHANNEL_WIDTH_80 )
1399                 {
1400                         if ( (MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1401                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
1402                         if ( (MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1403                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_2S];
1404                         if ( (MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1405                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_3S];
1406                         if ( (MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1407                                 txPower += pHalData->BW40_24G_Diff[RFPath][TX_4S];
1408
1409                         //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'),
1410                         //      pHalData->BW40_24G_Diff[RFPath][TX_1S], pHalData->BW40_24G_Diff[RFPath][TX_2S],
1411                         //      pHalData->BW40_24G_Diff[RFPath][TX_3S], pHalData->BW40_24G_Diff[RFPath][TX_4S]);
1412                 }
1413         }
1414         else //3 ============================== 5 G ==============================
1415         {
1416                 if ( MGN_6M <= Rate )
1417                 {
1418                         txPower = pHalData->Index5G_BW40_Base[RFPath][chnlIdx];
1419                 }
1420                 else
1421                 {
1422                         DBG_871X("===> mpt_ProQueryCalTxPower_Jaguar: INVALID Rate.\n");
1423                 }
1424
1425                 //DBG_871X("Base Tx power(RF-%c, Rate #%d, Channel Index %d) = 0x%X\n",
1426                 //      ((RFPath==0)?'A':'B'), Rate, chnlIdx, txPower);
1427
1428                 // OFDM-1T
1429                 if ( (MGN_6M <= Rate && Rate <= MGN_54M) && ! IS_CCK_RATE(Rate))
1430                 {
1431                         txPower += pHalData->OFDM_5G_Diff[RFPath][TX_1S];
1432                         //DBG_871X("+PowerDiff 5G (RF-%c): (OFDM-1T) = (%d)\n", ((RFPath==0)?'A':'B'), pHalData->OFDM_5G_Diff[RFPath][TX_1S]);
1433                 }
1434
1435                 // BW20-1S, BW20-2S
1436                 if (BandWidth == CHANNEL_WIDTH_20)
1437                 {
1438                         if ( (MGN_MCS0 <= Rate && Rate <= MGN_MCS31)  || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1439                                 txPower += pHalData->BW20_5G_Diff[RFPath][TX_1S];
1440                         if ( (MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1441                                 txPower += pHalData->BW20_5G_Diff[RFPath][TX_2S];
1442                         if ( (MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1443                                 txPower += pHalData->BW20_5G_Diff[RFPath][TX_3S];
1444                         if ( (MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1445                                 txPower += pHalData->BW20_5G_Diff[RFPath][TX_4S];
1446
1447                         //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'),
1448                         //      pHalData->BW20_5G_Diff[RFPath][TX_1S], pHalData->BW20_5G_Diff[RFPath][TX_2S],
1449                         //      pHalData->BW20_5G_Diff[RFPath][TX_3S], pHalData->BW20_5G_Diff[RFPath][TX_4S]);
1450                 }
1451                 // BW40-1S, BW40-2S
1452                 else if (BandWidth == CHANNEL_WIDTH_40)
1453                 {
1454                         if ( (MGN_MCS0 <= Rate && Rate <= MGN_MCS31)  || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1455                                 txPower += pHalData->BW40_5G_Diff[RFPath][TX_1S];
1456                         if ( (MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1457                                 txPower += pHalData->BW40_5G_Diff[RFPath][TX_2S];
1458                         if ( (MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1459                                 txPower += pHalData->BW40_5G_Diff[RFPath][TX_3S];
1460                         if ( (MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1461                                 txPower += pHalData->BW40_5G_Diff[RFPath][TX_4S];
1462
1463                         //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'),
1464                         //      pHalData->BW40_5G_Diff[RFPath][TX_1S], pHalData->BW40_5G_Diff[RFPath][TX_2S],
1465                         //      pHalData->BW40_5G_Diff[RFPath][TX_3S], pHalData->BW40_5G_Diff[RFPath][TX_4S]);
1466                 }
1467                 // BW80-1S, BW80-2S
1468                 else if (BandWidth== CHANNEL_WIDTH_80)
1469                 {
1470                         // <20121220, Kordan> Get the index of array "Index5G_BW80_Base".
1471                         u8      channel5G_80M[CHANNEL_MAX_NUMBER_5G_80M] = {42, 58, 106, 122, 138, 155, 171};
1472                         for (i = 0; i < sizeof(channel5G_80M)/sizeof(u8); ++i)
1473                                 if ( channel5G_80M[i] == Channel)
1474                                         chnlIdx = i;
1475
1476                         txPower = pHalData->Index5G_BW80_Base[RFPath][chnlIdx];
1477
1478                         if ( (MGN_MCS0 <= Rate && Rate <= MGN_MCS31)  || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1479                                 txPower += + pHalData->BW80_5G_Diff[RFPath][TX_1S];
1480                         if ( (MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1481                                 txPower += pHalData->BW80_5G_Diff[RFPath][TX_2S];
1482                         if ( (MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1483                                 txPower += pHalData->BW80_5G_Diff[RFPath][TX_3S];
1484                         if ( (MGN_MCS23 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1485                                 txPower += pHalData->BW80_5G_Diff[RFPath][TX_4S];
1486
1487                         //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'),
1488                         //      pHalData->BW80_5G_Diff[RFPath][TX_1S], pHalData->BW80_5G_Diff[RFPath][TX_2S],
1489                         //      pHalData->BW80_5G_Diff[RFPath][TX_3S], pHalData->BW80_5G_Diff[RFPath][TX_4S]);
1490                 }
1491         }
1492
1493         return txPower;
1494 }
1495
1496 s8
1497 PHY_GetTxPowerTrackingOffset(
1498         PADAPTER        pAdapter,
1499         u8                      RFPath,
1500         u8                      Rate
1501         )
1502 {
1503         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(pAdapter);
1504         PDM_ODM_T                       pDM_Odm = &pHalData->odmpriv;
1505         s8      offset = 0;
1506
1507         if( pDM_Odm->RFCalibrateInfo.TxPowerTrackControl  == _FALSE)
1508                 return offset;
1509
1510         if ((Rate == MGN_1M) ||(Rate == MGN_2M)||(Rate == MGN_5_5M)||(Rate == MGN_11M))
1511         {
1512                 offset = pDM_Odm->Remnant_CCKSwingIdx;
1513                 //DBG_871X("+Remnant_CCKSwingIdx = 0x%x\n", RFPath, Rate, pDM_Odm->Remnant_CCKSwingIdx);
1514         }
1515         else
1516         {
1517                 offset = pDM_Odm->Remnant_OFDMSwingIdx[RFPath];
1518                 //DBG_871X("+Remanant_OFDMSwingIdx[RFPath %u][Rate 0x%x] = 0x%x\n", RFPath, Rate, pDM_Odm->Remnant_OFDMSwingIdx[RFPath]);
1519
1520         }
1521
1522         return offset;
1523 }
1524
1525 u8
1526 PHY_GetRateIndexOfTxPowerByRate(
1527         IN      u8              Rate
1528         )
1529 {
1530         u8      index = 0;
1531         switch ( Rate )
1532         {
1533                 case MGN_1M: index = 0; break;
1534                 case MGN_2M: index = 1; break;
1535                 case MGN_5_5M: index = 2; break;
1536                 case MGN_11M: index = 3; break;
1537                 case MGN_6M: index = 4; break;
1538                 case MGN_9M: index = 5; break;
1539                 case MGN_12M: index = 6; break;
1540                 case MGN_18M: index = 7; break;
1541                 case MGN_24M: index = 8; break;
1542                 case MGN_36M: index = 9; break;
1543                 case MGN_48M: index = 10; break;
1544                 case MGN_54M: index = 11; break;
1545                 case MGN_MCS0: index = 12; break;
1546                 case MGN_MCS1: index = 13; break;
1547                 case MGN_MCS2: index = 14; break;
1548                 case MGN_MCS3: index = 15; break;
1549                 case MGN_MCS4: index = 16; break;
1550                 case MGN_MCS5: index = 17; break;
1551                 case MGN_MCS6: index = 18; break;
1552                 case MGN_MCS7: index = 19; break;
1553                 case MGN_MCS8: index = 20; break;
1554                 case MGN_MCS9: index = 21; break;
1555                 case MGN_MCS10: index = 22; break;
1556                 case MGN_MCS11: index = 23; break;
1557                 case MGN_MCS12: index = 24; break;
1558                 case MGN_MCS13: index = 25; break;
1559                 case MGN_MCS14: index = 26; break;
1560                 case MGN_MCS15: index = 27; break;
1561                 case MGN_MCS16: index = 28; break;
1562                 case MGN_MCS17: index = 29; break;
1563                 case MGN_MCS18: index = 30; break;
1564                 case MGN_MCS19: index = 31; break;
1565                 case MGN_MCS20: index = 32; break;
1566                 case MGN_MCS21: index = 33; break;
1567                 case MGN_MCS22: index = 34; break;
1568                 case MGN_MCS23: index = 35; break;
1569                 case MGN_MCS24: index = 36; break;
1570                 case MGN_MCS25: index = 37; break;
1571                 case MGN_MCS26: index = 38; break;
1572                 case MGN_MCS27: index = 39; break;
1573                 case MGN_MCS28: index = 40; break;
1574                 case MGN_MCS29: index = 41; break;
1575                 case MGN_MCS30: index = 42; break;
1576                 case MGN_MCS31: index = 43; break;
1577                 case MGN_VHT1SS_MCS0: index = 44; break;
1578                 case MGN_VHT1SS_MCS1: index = 45; break;
1579                 case MGN_VHT1SS_MCS2: index = 46; break;
1580                 case MGN_VHT1SS_MCS3: index = 47; break;
1581                 case MGN_VHT1SS_MCS4: index = 48; break;
1582                 case MGN_VHT1SS_MCS5: index = 49; break;
1583                 case MGN_VHT1SS_MCS6: index = 50; break;
1584                 case MGN_VHT1SS_MCS7: index = 51; break;
1585                 case MGN_VHT1SS_MCS8: index = 52; break;
1586                 case MGN_VHT1SS_MCS9: index = 53; break;
1587                 case MGN_VHT2SS_MCS0: index = 54; break;
1588                 case MGN_VHT2SS_MCS1: index = 55; break;
1589                 case MGN_VHT2SS_MCS2: index = 56; break;
1590                 case MGN_VHT2SS_MCS3: index = 57; break;
1591                 case MGN_VHT2SS_MCS4: index = 58; break;
1592                 case MGN_VHT2SS_MCS5: index = 59; break;
1593                 case MGN_VHT2SS_MCS6: index = 60; break;
1594                 case MGN_VHT2SS_MCS7: index = 61; break;
1595                 case MGN_VHT2SS_MCS8: index = 62; break;
1596                 case MGN_VHT2SS_MCS9: index = 63; break;
1597                 case MGN_VHT3SS_MCS0: index = 64; break;
1598                 case MGN_VHT3SS_MCS1: index = 65; break;
1599                 case MGN_VHT3SS_MCS2: index = 66; break;
1600                 case MGN_VHT3SS_MCS3: index = 67; break;
1601                 case MGN_VHT3SS_MCS4: index = 68; break;
1602                 case MGN_VHT3SS_MCS5: index = 69; break;
1603                 case MGN_VHT3SS_MCS6: index = 70; break;
1604                 case MGN_VHT3SS_MCS7: index = 71; break;
1605                 case MGN_VHT3SS_MCS8: index = 72; break;
1606                 case MGN_VHT3SS_MCS9: index = 73; break;
1607                 case MGN_VHT4SS_MCS0: index = 74; break;
1608                 case MGN_VHT4SS_MCS1: index = 75; break;
1609                 case MGN_VHT4SS_MCS2: index = 76; break;
1610                 case MGN_VHT4SS_MCS3: index = 77; break;
1611                 case MGN_VHT4SS_MCS4: index = 78; break;
1612                 case MGN_VHT4SS_MCS5: index = 79; break;
1613                 case MGN_VHT4SS_MCS6: index = 80; break;
1614                 case MGN_VHT4SS_MCS7: index = 81; break;
1615                 case MGN_VHT4SS_MCS8: index = 82; break;
1616                 case MGN_VHT4SS_MCS9: index = 83; break;
1617                 default:
1618                         DBG_871X("Invalid rate 0x%x in %s\n", Rate, __FUNCTION__ );
1619                         break;
1620         };
1621
1622         return index;
1623 }
1624
1625 s8
1626 PHY_GetTxPowerByRate(
1627         IN      PADAPTER        pAdapter,
1628         IN      u8                      Band,
1629         IN      u8                      RFPath,
1630         IN      u8                      TxNum,
1631         IN      u8                      Rate
1632         )
1633 {
1634         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
1635         s8                      value = 0, limit = 0;
1636         u8                      rateIndex = PHY_GetRateIndexOfTxPowerByRate( Rate );
1637
1638         if ( ( pAdapter->registrypriv.RegEnableTxPowerByRate == 2 && pHalData->EEPROMRegulatory == 2 ) ||
1639                    pAdapter->registrypriv.RegEnableTxPowerByRate == 0 )
1640                 return 0;
1641
1642         if ( Band != BAND_ON_2_4G && Band != BAND_ON_5G )
1643         {
1644                 DBG_871X("Invalid band %d in %s\n", Band, __FUNCTION__ );
1645                 return value;
1646         }
1647         if ( RFPath > ODM_RF_PATH_D )
1648         {
1649                 DBG_871X("Invalid RfPath %d in %s\n", RFPath, __FUNCTION__ );
1650                 return value;
1651         }
1652         if ( TxNum >= RF_MAX_TX_NUM )
1653         {
1654                 DBG_871X("Invalid TxNum %d in %s\n", TxNum, __FUNCTION__ );
1655                 return value;
1656         }
1657         if ( rateIndex >= TX_PWR_BY_RATE_NUM_RATE )
1658         {
1659                 DBG_871X("Invalid RateIndex %d in %s\n", rateIndex, __FUNCTION__ );
1660                 return value;
1661         }
1662
1663         value = pHalData->TxPwrByRateOffset[Band][RFPath][TxNum][rateIndex];
1664
1665         return value;
1666
1667 }
1668
1669 VOID
1670 PHY_SetTxPowerByRate(
1671         IN      PADAPTER        pAdapter,
1672         IN      u8                      Band,
1673         IN      u8                      RFPath,
1674         IN      u8                      TxNum,
1675         IN      u8                      Rate,
1676         IN      s8                      Value
1677         )
1678 {
1679         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA( pAdapter );
1680         u8      rateIndex = PHY_GetRateIndexOfTxPowerByRate( Rate );
1681
1682         if ( Band != BAND_ON_2_4G && Band != BAND_ON_5G )
1683         {
1684                 DBG_871X("Invalid band %d in %s\n", Band, __FUNCTION__ );
1685                 return;
1686         }
1687         if ( RFPath > ODM_RF_PATH_D )
1688         {
1689                 DBG_871X("Invalid RfPath %d in %s\n", RFPath, __FUNCTION__ );
1690                 return;
1691         }
1692         if ( TxNum >= RF_MAX_TX_NUM )
1693         {
1694                 DBG_871X( "Invalid TxNum %d in %s\n", TxNum, __FUNCTION__ );
1695                 return;
1696         }
1697         if ( rateIndex >= TX_PWR_BY_RATE_NUM_RATE )
1698         {
1699                 DBG_871X("Invalid RateIndex %d in %s\n", rateIndex, __FUNCTION__ );
1700                 return;
1701         }
1702
1703         pHalData->TxPwrByRateOffset[Band][RFPath][TxNum][rateIndex] = Value;
1704 }
1705
1706 VOID
1707 PHY_SetTxPowerLevelByPath(
1708         IN      PADAPTER        Adapter,
1709         IN      u8                      channel,
1710         IN      u8                      path
1711         )
1712 {
1713         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(Adapter);
1714         BOOLEAN bIsIn24G = (pHalData->CurrentBandType == BAND_ON_2_4G );
1715
1716         //if ( pMgntInfo->RegNByteAccess == 0 )
1717         {
1718                 if ( bIsIn24G )
1719                         PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, CCK );
1720
1721                 PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, OFDM );
1722                 PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, HT_MCS0_MCS7 );
1723
1724                 if ( IS_HARDWARE_TYPE_JAGUAR( Adapter ) || IS_HARDWARE_TYPE_8813A( Adapter ) )
1725                         PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, VHT_1SSMCS0_1SSMCS9 );
1726
1727                 if ( pHalData->NumTotalRFPath >= 2 )
1728                 {
1729                         PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, HT_MCS8_MCS15 );
1730
1731                         if ( IS_HARDWARE_TYPE_JAGUAR( Adapter ) || IS_HARDWARE_TYPE_8813A( Adapter ) )
1732                                 PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, VHT_2SSMCS0_2SSMCS9 );
1733
1734                         if ( IS_HARDWARE_TYPE_8813A( Adapter ) )
1735                         {
1736                                 PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, HT_MCS16_MCS23 );
1737                                 PHY_SetTxPowerIndexByRateSection( Adapter, path, channel, VHT_3SSMCS0_3SSMCS9 );
1738                         }
1739                 }
1740         }
1741 }
1742
1743 VOID
1744 PHY_SetTxPowerIndexByRateArray(
1745         IN      PADAPTER                        pAdapter,
1746         IN      u8                                      RFPath,
1747         IN      CHANNEL_WIDTH           BandWidth,
1748         IN      u8                                      Channel,
1749         IN      u8*                                     Rates,
1750         IN      u8                                      RateArraySize
1751         )
1752 {
1753         u32     powerIndex = 0;
1754         int     i = 0;
1755
1756         for (i = 0; i < RateArraySize; ++i)
1757         {
1758                 powerIndex = PHY_GetTxPowerIndex(pAdapter, RFPath, Rates[i], BandWidth, Channel);
1759                 PHY_SetTxPowerIndex(pAdapter, powerIndex, RFPath, Rates[i]);
1760         }
1761 }
1762
1763 s8
1764 phy_GetWorldWideLimit(
1765         s8* LimitTable
1766 )
1767 {
1768         s8      min = LimitTable[0];
1769         u8      i = 0;
1770
1771         for (i = 0; i < MAX_REGULATION_NUM; ++i) {
1772                 if (LimitTable[i] < min)
1773                         min = LimitTable[i];
1774         }
1775
1776         return min;
1777 }
1778
1779 s8
1780 phy_GetChannelIndexOfTxPowerLimit(
1781         IN      u8                      Band,
1782         IN      u8                      Channel
1783         )
1784 {
1785         s8      channelIndex = -1;
1786         u8      channel5G[CHANNEL_MAX_NUMBER_5G] =
1787                                  {36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,100,102,104,106,108,110,112,
1788                                 114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,149,151,
1789                                 153,155,157,159,161,163,165,167,168,169,171,173,175,177};
1790         u8      i = 0;
1791         if ( Band == BAND_ON_2_4G )
1792         {
1793                 channelIndex = Channel - 1;
1794         }
1795         else if ( Band == BAND_ON_5G )
1796         {
1797                 for ( i = 0; i < sizeof(channel5G)/sizeof(u8); ++i )
1798                 {
1799                         if ( channel5G[i] == Channel )
1800                                 channelIndex = i;
1801                 }
1802         }
1803         else
1804         {
1805                 DBG_871X("Invalid Band %d in %s", Band, __FUNCTION__ );
1806         }
1807
1808         if ( channelIndex == -1 )
1809                 DBG_871X("Invalid Channel %d of Band %d in %s", Channel, Band, __FUNCTION__ );
1810
1811         return channelIndex;
1812 }
1813
1814 s8
1815 PHY_GetTxPowerLimit(
1816         IN      PADAPTER                        Adapter,
1817         IN      u32                                     RegPwrTblSel,
1818         IN      BAND_TYPE                       Band,
1819         IN      CHANNEL_WIDTH           Bandwidth,
1820         IN      u8                                      RfPath,
1821         IN      u8                                      DataRate,
1822         IN      u8                                      Channel
1823         )
1824 {
1825         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
1826         s16                             band = -1, regulation = -1, bandwidth = -1,
1827                                         rateSection = -1, channel = -1;
1828         s8                              powerLimit = MAX_POWER_INDEX;
1829
1830         if ( ( Adapter->registrypriv.RegEnableTxPowerLimit == 2 && pHalData->EEPROMRegulatory != 1 ) ||
1831                    Adapter->registrypriv.RegEnableTxPowerLimit == 0 )
1832                 return MAX_POWER_INDEX;
1833
1834         switch( Adapter->registrypriv.RegPwrTblSel )
1835         {
1836                 case 1:
1837                                 regulation = TXPWR_LMT_ETSI;
1838                                 break;
1839                 case 2:
1840                                 regulation = TXPWR_LMT_MKK;
1841                                 break;
1842                 case 3:
1843                                 regulation = TXPWR_LMT_FCC;
1844                                 break;
1845
1846                 case 4:
1847                                 regulation = TXPWR_LMT_WW;
1848                                 break;
1849
1850                 default:
1851                                 regulation = ( Band == BAND_ON_2_4G ) ? pHalData->Regulation2_4G
1852                                                                           : pHalData->Regulation5G;
1853                                 break;
1854         }
1855
1856         //DBG_871X("pMgntInfo->RegPwrTblSel %d, final regulation %d\n", Adapter->registrypriv.RegPwrTblSel, regulation );
1857
1858
1859         if ( Band == BAND_ON_2_4G ) band = 0;
1860         else if ( Band == BAND_ON_5G ) band = 1;
1861
1862         if ( Bandwidth == CHANNEL_WIDTH_20 ) bandwidth = 0;
1863         else if ( Bandwidth == CHANNEL_WIDTH_40 ) bandwidth = 1;
1864         else if ( Bandwidth == CHANNEL_WIDTH_80 ) bandwidth = 2;
1865         else if ( Bandwidth == CHANNEL_WIDTH_160 ) bandwidth = 3;
1866
1867         switch ( DataRate )
1868         {
1869                 case MGN_1M: case MGN_2M: case MGN_5_5M: case MGN_11M:
1870                         rateSection = 0;
1871                         break;
1872
1873                 case MGN_6M: case MGN_9M: case MGN_12M: case MGN_18M:
1874                 case MGN_24M: case MGN_36M: case MGN_48M: case MGN_54M:
1875                         rateSection = 1;
1876                         break;
1877
1878                 case MGN_MCS0: case MGN_MCS1: case MGN_MCS2: case MGN_MCS3:
1879                 case MGN_MCS4: case MGN_MCS5: case MGN_MCS6: case MGN_MCS7:
1880                         rateSection = 2;
1881                         break;
1882
1883                 case MGN_MCS8: case MGN_MCS9: case MGN_MCS10: case MGN_MCS11:
1884                 case MGN_MCS12: case MGN_MCS13: case MGN_MCS14: case MGN_MCS15:
1885                         rateSection = 3;
1886                         break;
1887
1888                 case MGN_MCS16: case MGN_MCS17: case MGN_MCS18: case MGN_MCS19:
1889                 case MGN_MCS20: case MGN_MCS21: case MGN_MCS22: case MGN_MCS23:
1890                         rateSection = 4;
1891                         break;
1892
1893                 case MGN_MCS24: case MGN_MCS25: case MGN_MCS26: case MGN_MCS27:
1894                 case MGN_MCS28: case MGN_MCS29: case MGN_MCS30: case MGN_MCS31:
1895                         rateSection = 5;
1896                         break;
1897
1898                 case MGN_VHT1SS_MCS0: case MGN_VHT1SS_MCS1: case MGN_VHT1SS_MCS2:
1899                 case MGN_VHT1SS_MCS3: case MGN_VHT1SS_MCS4: case MGN_VHT1SS_MCS5:
1900                 case MGN_VHT1SS_MCS6: case MGN_VHT1SS_MCS7: case MGN_VHT1SS_MCS8:
1901                 case MGN_VHT1SS_MCS9:
1902                         rateSection = 6;
1903                         break;
1904
1905                 case MGN_VHT2SS_MCS0: case MGN_VHT2SS_MCS1: case MGN_VHT2SS_MCS2:
1906                 case MGN_VHT2SS_MCS3: case MGN_VHT2SS_MCS4: case MGN_VHT2SS_MCS5:
1907                 case MGN_VHT2SS_MCS6: case MGN_VHT2SS_MCS7: case MGN_VHT2SS_MCS8:
1908                 case MGN_VHT2SS_MCS9:
1909                         rateSection = 7;
1910                         break;
1911
1912                 case MGN_VHT3SS_MCS0: case MGN_VHT3SS_MCS1: case MGN_VHT3SS_MCS2:
1913                 case MGN_VHT3SS_MCS3: case MGN_VHT3SS_MCS4: case MGN_VHT3SS_MCS5:
1914                 case MGN_VHT3SS_MCS6: case MGN_VHT3SS_MCS7: case MGN_VHT3SS_MCS8:
1915                 case MGN_VHT3SS_MCS9:
1916                         rateSection = 8;
1917                         break;
1918
1919                 case MGN_VHT4SS_MCS0: case MGN_VHT4SS_MCS1: case MGN_VHT4SS_MCS2:
1920                 case MGN_VHT4SS_MCS3: case MGN_VHT4SS_MCS4: case MGN_VHT4SS_MCS5:
1921                 case MGN_VHT4SS_MCS6: case MGN_VHT4SS_MCS7: case MGN_VHT4SS_MCS8:
1922                 case MGN_VHT4SS_MCS9:
1923                         rateSection = 9;
1924                         break;
1925
1926                 default:
1927                         DBG_871X("Wrong rate 0x%x\n", DataRate );
1928                         break;
1929         }
1930
1931         if ( Band == BAND_ON_5G  && rateSection == 0 )
1932                         DBG_871X("Wrong rate 0x%x: No CCK in 5G Band\n", DataRate );
1933
1934         // workaround for wrong index combination to obtain tx power limit,
1935         // OFDM only exists in BW 20M
1936         if ( rateSection == 1 )
1937                 bandwidth = 0;
1938
1939         // workaround for wrong index combination to obtain tx power limit,
1940         // CCK table will only be given in BW 20M
1941         if ( rateSection == 0 )
1942                 bandwidth = 0;
1943
1944         // workaround for wrong indxe combination to obtain tx power limit,
1945         // HT on 80M will reference to HT on 40M
1946         if ( ( rateSection == 2 || rateSection == 3 ) && Band == BAND_ON_5G && bandwidth == 2 ) {
1947                 bandwidth = 1;
1948         }
1949
1950         if ( Band == BAND_ON_2_4G )
1951                 channel = phy_GetChannelIndexOfTxPowerLimit( BAND_ON_2_4G, Channel );
1952         else if ( Band == BAND_ON_5G )
1953                 channel = phy_GetChannelIndexOfTxPowerLimit( BAND_ON_5G, Channel );
1954         else if ( Band == BAND_ON_BOTH )
1955         {
1956                 // BAND_ON_BOTH don't care temporarily
1957         }
1958
1959         if ( band == -1 || regulation == -1 || bandwidth == -1 ||
1960              rateSection == -1 || channel == -1 )
1961         {
1962                 //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",
1963                 //        band, regulation, bandwidth, RfPath, rateSection, channelGroup );
1964
1965                 return MAX_POWER_INDEX;
1966         }
1967
1968         if ( Band == BAND_ON_2_4G ) {
1969                 s8 limits[10] = {0}; u8 i = 0;
1970                 for (i = 0; i < MAX_REGULATION_NUM; ++i)
1971                         limits[i] = pHalData->TxPwrLimit_2_4G[i][bandwidth][rateSection][channel][RfPath];
1972
1973                 powerLimit = (regulation == TXPWR_LMT_WW) ? phy_GetWorldWideLimit(limits) :
1974                                   pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channel][RfPath];
1975
1976         } else if ( Band == BAND_ON_5G ) {
1977                 s8 limits[10] = {0}; u8 i = 0;
1978                 for (i = 0; i < MAX_REGULATION_NUM; ++i)
1979                         limits[i] = pHalData->TxPwrLimit_5G[i][bandwidth][rateSection][channel][RfPath];
1980
1981                 powerLimit = (regulation == TXPWR_LMT_WW) ? phy_GetWorldWideLimit(limits) :
1982                                           pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channel][RfPath];
1983         } else
1984                 DBG_871X("No power limit table of the specified band\n" );
1985
1986         // combine 5G VHT & HT rate
1987         // 5G 20M and 40M HT and VHT can cross reference
1988         /*
1989         if ( Band == BAND_ON_5G && powerLimit == MAX_POWER_INDEX ) {
1990                 if ( bandwidth == 0 || bandwidth == 1 ) {
1991                         RT_TRACE( COMP_INIT, DBG_LOUD, ( "No power limit table of the specified band %d, bandwidth %d, ratesection %d, rf path %d\n",
1992                                           band, bandwidth, rateSection, RfPath ) );
1993                         if ( rateSection == 2 )
1994                                 powerLimit = pHalData->TxPwrLimit_5G[regulation]
1995                                                                                 [bandwidth][4][channelGroup][RfPath];
1996                         else if ( rateSection == 4 )
1997                                 powerLimit = pHalData->TxPwrLimit_5G[regulation]
1998                                                                                 [bandwidth][2][channelGroup][RfPath];
1999                         else if ( rateSection == 3 )
2000                                 powerLimit = pHalData->TxPwrLimit_5G[regulation]
2001                                                                                 [bandwidth][5][channelGroup][RfPath];
2002                         else if ( rateSection == 5 )
2003                                 powerLimit = pHalData->TxPwrLimit_5G[regulation]
2004                                                                                 [bandwidth][3][channelGroup][RfPath];
2005                 }
2006         }
2007         */
2008         //DBG_871X("TxPwrLmt[Regulation %d][Band %d][BW %d][RFPath %d][Rate 0x%x][Chnl %d] = %d\n",
2009         //              regulation, pHalData->CurrentBandType, Bandwidth, RfPath, DataRate, Channel, powerLimit);
2010         return powerLimit;
2011 }
2012
2013 VOID
2014 phy_CrossReferenceHTAndVHTTxPowerLimit(
2015         IN      PADAPTER                        pAdapter
2016         )
2017 {
2018         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(pAdapter);
2019         u8                              regulation, bw, channel, rateSection;
2020         s8                              tempPwrLmt = 0;
2021
2022         for ( regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation )
2023         {
2024                 for ( bw = 0; bw < MAX_5G_BANDWITH_NUM; ++bw )
2025                 {
2026                         for ( channel = 0; channel < CHANNEL_MAX_NUMBER_5G; ++channel )
2027                         {
2028                                 for ( rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection )
2029                                 {
2030                                         tempPwrLmt = pHalData->TxPwrLimit_5G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
2031                                         if ( tempPwrLmt == MAX_POWER_INDEX )
2032                                         {
2033                                                 u8      baseSection = 2, refSection = 6;
2034                                                 if ( bw == 0 || bw == 1 ) { // 5G 20M 40M VHT and HT can cross reference
2035                                                         //DBG_871X("No power limit table of the specified band %d, bandwidth %d, ratesection %d, channel %d, rf path %d\n",
2036                                                         //                      1, bw, rateSection, channel, ODM_RF_PATH_A );
2037                                                         if ( rateSection >= 2 && rateSection <= 9 ) {
2038                                                                 if ( rateSection == 2 )
2039                                                                 {
2040                                                                         baseSection = 2;
2041                                                                         refSection = 6;
2042                                                                 }
2043                                                                 else if ( rateSection == 3 )
2044                                                                 {
2045                                                                         baseSection = 3;
2046                                                                         refSection = 7;
2047                                                                 }
2048                                                                 else if ( rateSection == 4 )
2049                                                                 {
2050                                                                         baseSection = 4;
2051                                                                         refSection = 8;
2052                                                                 }
2053                                                                 else if ( rateSection == 5 )
2054                                                                 {
2055                                                                         baseSection = 5;
2056                                                                         refSection = 9;
2057                                                                 }
2058                                                                 else if ( rateSection == 6 )
2059                                                                 {
2060                                                                         baseSection = 6;
2061                                                                         refSection = 2;
2062                                                                 }
2063                                                                 else if ( rateSection == 7 )
2064                                                                 {
2065                                                                         baseSection = 7;
2066                                                                         refSection = 3;
2067                                                                 }
2068                                                                 else if ( rateSection == 8 )
2069                                                                 {
2070                                                                         baseSection = 8;
2071                                                                         refSection = 4;
2072                                                                 }
2073                                                                 else if ( rateSection == 9 )
2074                                                                 {
2075                                                                         baseSection = 9;
2076                                                                         refSection = 5;
2077                                                                 }
2078                                                                 pHalData->TxPwrLimit_5G[regulation][bw][baseSection][channel][ODM_RF_PATH_A] =
2079                                                                         pHalData->TxPwrLimit_5G[regulation][bw][refSection][channel][ODM_RF_PATH_A];
2080                                                         }
2081
2082                                                         //DBG_871X("use other value %d", tempPwrLmt );
2083                                                 }
2084                                         }
2085                                 }
2086                         }
2087                 }
2088         }
2089 }
2090
2091 VOID
2092 PHY_ConvertTxPowerLimitToPowerIndex(
2093         IN      PADAPTER                        Adapter
2094         )
2095 {
2096         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
2097         u8                              BW40PwrBasedBm2_4G = 0x2E, BW40PwrBasedBm5G = 0x2E;
2098         u8                              regulation, bw, channel, rateSection;
2099         u8                              baseIndex2_4G;
2100         u8                              baseIndex5G;
2101         s8                              tempValue = 0, tempPwrLmt = 0;
2102         u8                              rfPath = 0;
2103
2104         //DBG_871X("=====> PHY_ConvertTxPowerLimitToPowerIndex()\n" );
2105
2106         phy_CrossReferenceHTAndVHTTxPowerLimit( Adapter );
2107
2108         for ( regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation )
2109         {
2110                 for ( bw = 0; bw < MAX_2_4G_BANDWITH_NUM; ++bw )
2111                 {
2112                         for ( channel = 0; channel < CHANNEL_MAX_NUMBER_2G; ++channel )
2113                         {
2114                                 for ( rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection )
2115                                 {
2116                                         tempPwrLmt = pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
2117
2118                                         for ( rfPath = ODM_RF_PATH_A; rfPath < MAX_RF_PATH_NUM; ++rfPath )
2119                                         {
2120                                                 if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE )
2121                                                 {
2122                                                         if ( rateSection == 5 ) // HT 4T
2123                                                                 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_4TX, HT_MCS24_MCS31 );
2124                                                         else if ( rateSection == 4 ) // HT 3T
2125                                                                 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_3TX, HT_MCS16_MCS23 );
2126                                                         else if ( rateSection == 3 ) // HT 2T
2127                                                                 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_2TX, HT_MCS8_MCS15 );
2128                                                         else if ( rateSection == 2 ) // HT 1T
2129                                                                 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_1TX, HT_MCS0_MCS7 );
2130                                                         else if ( rateSection == 1 ) // OFDM
2131                                                                 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_1TX, OFDM );
2132                                                         else if ( rateSection == 0 ) // CCK
2133                                                                 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_1TX, CCK );
2134                                                 }
2135                                                 else
2136                                                         BW40PwrBasedBm2_4G = Adapter->registrypriv.RegPowerBase * 2;
2137
2138                                                 if ( tempPwrLmt != MAX_POWER_INDEX ) {
2139                                                         tempValue = tempPwrLmt - BW40PwrBasedBm2_4G;
2140                                                         pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][rfPath] = tempValue;
2141                                                 }
2142                                         }
2143                                 }
2144                         }
2145                 }
2146         }
2147
2148         if ( IS_HARDWARE_TYPE_JAGUAR( Adapter ) || IS_HARDWARE_TYPE_8813A( Adapter ) )
2149         {
2150                 for ( regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation )
2151                 {
2152                         for ( bw = 0; bw < MAX_5G_BANDWITH_NUM; ++bw )
2153                         {
2154                                 for ( channel = 0; channel < CHANNEL_MAX_NUMBER_5G; ++channel )
2155                                 {
2156                                         for ( rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection )
2157                                         {
2158                                                 tempPwrLmt = pHalData->TxPwrLimit_5G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
2159
2160                                                 for ( rfPath = ODM_RF_PATH_A; rfPath < MAX_RF_PATH_NUM; ++rfPath )
2161                                                 {
2162                                                         if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE )
2163                                                         {
2164                                                                 if ( rateSection == 9 ) // VHT 4SS
2165                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_4TX, VHT_4SSMCS0_4SSMCS9);
2166                                                                 else if ( rateSection == 8 ) // VHT 3SS
2167                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_3TX, VHT_3SSMCS0_3SSMCS9 );
2168                                                                 else if ( rateSection == 7 ) // VHT 2SS
2169                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_2TX, VHT_2SSMCS0_2SSMCS9 );
2170                                                                 else if ( rateSection == 6 ) // VHT 1SS
2171                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_1TX, VHT_1SSMCS0_1SSMCS9 );
2172                                                                 else if ( rateSection == 5 ) // HT 4T
2173                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_4TX, HT_MCS24_MCS31 );
2174                                                                 else if ( rateSection == 4 ) // HT 3T
2175                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_3TX, HT_MCS16_MCS23 );
2176                                                                 else if ( rateSection == 3 ) // HT 2T
2177                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_2TX, HT_MCS8_MCS15 );
2178                                                                 else if ( rateSection == 2 ) // HT 1T
2179                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_1TX, HT_MCS0_MCS7 );
2180                                                                 else if ( rateSection == 1 ) // OFDM
2181                                                                         BW40PwrBasedBm5G = PHY_GetTxPowerByRateBase( Adapter, BAND_ON_2_4G, rfPath, RF_1TX, OFDM );
2182                                                         }
2183                                                         else
2184                                                                 BW40PwrBasedBm5G = Adapter->registrypriv.RegPowerBase * 2;
2185
2186                                                         if ( tempPwrLmt != MAX_POWER_INDEX ) {
2187                                                                 tempValue = tempPwrLmt - BW40PwrBasedBm5G;
2188                                                                 pHalData->TxPwrLimit_5G[regulation][bw][rateSection][channel][rfPath] = tempValue;
2189                                                         }
2190                                                 }
2191                                         }
2192                                 }
2193                         }
2194                 }
2195         }
2196         //DBG_871X("<===== PHY_ConvertTxPowerLimitToPowerIndex()\n" );
2197 }
2198
2199 VOID
2200 PHY_InitTxPowerLimit(
2201         IN      PADAPTER                Adapter
2202         )
2203 {
2204         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
2205         u8                              i, j, k, l, m;
2206
2207         //DBG_871X("=====> PHY_InitTxPowerLimit()!\n" );
2208
2209         for ( i = 0; i < MAX_REGULATION_NUM; ++i )
2210         {
2211                 for ( j = 0; j < MAX_2_4G_BANDWITH_NUM; ++j )
2212                         for ( k = 0; k < MAX_RATE_SECTION_NUM; ++k )
2213                                 for ( m = 0; m < CHANNEL_MAX_NUMBER_2G; ++m )
2214                                         for ( l = 0; l < MAX_RF_PATH_NUM; ++l )
2215                                                 pHalData->TxPwrLimit_2_4G[i][j][k][m][l] = MAX_POWER_INDEX;
2216         }
2217
2218         for ( i = 0; i < MAX_REGULATION_NUM; ++i )
2219         {
2220                 for ( j = 0; j < MAX_5G_BANDWITH_NUM; ++j )
2221                         for ( k = 0; k < MAX_RATE_SECTION_NUM; ++k )
2222                                 for ( m = 0; m < CHANNEL_MAX_NUMBER_5G; ++m )
2223                                         for ( l = 0; l < MAX_RF_PATH_NUM; ++l )
2224                                                 pHalData->TxPwrLimit_5G[i][j][k][m][l] = MAX_POWER_INDEX;
2225         }
2226
2227         //DBG_871X("<===== PHY_InitTxPowerLimit()!\n" );
2228 }
2229
2230 VOID
2231 PHY_SetTxPowerLimit(
2232         IN      PADAPTER                Adapter,
2233         IN      u8                              *Regulation,
2234         IN      u8                              *Band,
2235         IN      u8                              *Bandwidth,
2236         IN      u8                              *RateSection,
2237         IN      u8                              *RfPath,
2238         IN      u8                              *Channel,
2239         IN      u8                              *PowerLimit
2240         )
2241 {
2242         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA( Adapter );
2243         u8                              regulation=0, bandwidth=0, rateSection=0,
2244                                         channel;
2245         s8                              powerLimit = 0, prevPowerLimit, channelIndex;
2246
2247         //DBG_871X( "Index of power limit table [band %s][regulation %s][bw %s][rate section %s][rf path %s][chnl %s][val %s]\n",
2248         //        Band, Regulation, Bandwidth, RateSection, RfPath, Channel, PowerLimit );
2249
2250         if ( !GetU1ByteIntegerFromStringInDecimal( (s8 *)Channel, &channel ) ||
2251                  !GetU1ByteIntegerFromStringInDecimal( (s8 *)PowerLimit, &powerLimit ) )
2252         {
2253                 DBG_871X("Illegal index of power limit table [chnl %s][val %s]\n", Channel, PowerLimit );
2254         }
2255
2256         powerLimit = powerLimit > MAX_POWER_INDEX ? MAX_POWER_INDEX : powerLimit;
2257
2258         if ( eqNByte( Regulation, (u8 *)("FCC"), 3 ) ) regulation = 0;
2259         else if ( eqNByte( Regulation, (u8 *)("MKK"), 3 ) ) regulation = 1;
2260         else if ( eqNByte( Regulation, (u8 *)("ETSI"), 4 ) ) regulation = 2;
2261         else if ( eqNByte( Regulation, (u8 *)("WW13"), 4 ) ) regulation = 3;
2262
2263         if ( eqNByte( RateSection, (u8 *)("CCK"), 3 ) && eqNByte( RfPath, (u8 *)("1T"), 2 ) )
2264                 rateSection = 0;
2265         else if ( eqNByte( RateSection, (u8 *)("OFDM"), 4 ) && eqNByte( RfPath, (u8 *)("1T"), 2 ) )
2266                 rateSection = 1;
2267         else if ( eqNByte( RateSection, (u8 *)("HT"), 2 ) && eqNByte( RfPath, (u8 *)("1T"), 2 ) )
2268                 rateSection = 2;
2269         else if ( eqNByte( RateSection, (u8 *)("HT"), 2 ) && eqNByte( RfPath, (u8 *)("2T"), 2 ) )
2270                 rateSection = 3;
2271         else if ( eqNByte( RateSection, (u8 *)("HT"), 2 ) && eqNByte( RfPath, (u8 *)("3T"), 2 ) )
2272                 rateSection = 4;
2273         else if ( eqNByte( RateSection, (u8 *)("HT"), 2 ) && eqNByte( RfPath, (u8 *)("4T"), 2 ) )
2274                 rateSection = 5;
2275         else if ( eqNByte( RateSection, (u8 *)("VHT"), 3 ) && eqNByte( RfPath, (u8 *)("1T"), 2 ) )
2276                 rateSection = 6;
2277         else if ( eqNByte( RateSection, (u8 *)("VHT"), 3 ) && eqNByte( RfPath, (u8 *)("2T"), 2 ) )
2278                 rateSection = 7;
2279         else if ( eqNByte( RateSection, (u8 *)("VHT"), 3 ) && eqNByte( RfPath, (u8 *)("3T"), 2 ) )
2280                 rateSection = 8;
2281         else if ( eqNByte( RateSection, (u8 *)("VHT"), 3 ) && eqNByte( RfPath, (u8 *)("4T"), 2 ) )
2282                 rateSection = 9;
2283         else
2284         {
2285                 DBG_871X("Wrong rate section!\n");
2286                 return;
2287         }
2288
2289
2290         if ( eqNByte( Bandwidth, (u8 *)("20M"), 3 ) ) bandwidth = 0;
2291         else if ( eqNByte( Bandwidth, (u8 *)("40M"), 3 ) ) bandwidth = 1;
2292         else if ( eqNByte( Bandwidth, (u8 *)("80M"), 3 ) ) bandwidth = 2;
2293         else if ( eqNByte( Bandwidth, (u8 *)("160M"), 4 ) ) bandwidth = 3;
2294
2295         if ( eqNByte( Band, (u8 *)("2.4G"), 4 ) )
2296         {
2297                 channelIndex = phy_GetChannelIndexOfTxPowerLimit( BAND_ON_2_4G, channel );
2298
2299                 if ( channelIndex == -1 )
2300                         return;
2301
2302                 prevPowerLimit = pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A];
2303
2304                 if ( powerLimit < prevPowerLimit )
2305                         pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] = powerLimit;
2306
2307                 //DBG_871X( "2.4G Band value : [regulation %d][bw %d][rate_section %d][chnl %d][val %d]\n",
2308                 //        regulation, bandwidth, rateSection, channelIndex, pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] );
2309         }
2310         else if ( eqNByte( Band, (u8 *)("5G"), 2 ) )
2311         {
2312                 channelIndex = phy_GetChannelIndexOfTxPowerLimit( BAND_ON_5G, channel );
2313
2314                 if ( channelIndex == -1 )
2315                         return;
2316
2317                 prevPowerLimit = pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A];
2318
2319                 if ( powerLimit < prevPowerLimit )
2320                         pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] = powerLimit;
2321
2322                 //DBG_871X( "5G Band value : [regulation %d][bw %d][rate_section %d][chnl %d][val %d]\n",
2323                 //        regulation, bandwidth, rateSection, channel, pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] );
2324         }
2325         else
2326         {
2327                 DBG_871X("Cannot recognize the band info in %s\n", Band );
2328                 return;
2329         }
2330 }
2331
2332 u8
2333 PHY_GetTxPowerIndex(
2334         IN      PADAPTER                        pAdapter,
2335         IN      u8                                      RFPath,
2336         IN      u8                                      Rate,
2337         IN      CHANNEL_WIDTH           BandWidth,
2338         IN      u8                                      Channel
2339         )
2340 {
2341         u8      txPower = 0x3E;
2342
2343         if (IS_HARDWARE_TYPE_8813A(pAdapter)) {
2344 //#if (RTL8813A_SUPPORT==1)
2345 //              txPower = PHY_GetTxPowerIndex_8813A( pAdapter, PowerIndex, RFPath, Rate );
2346 //#endif
2347         }
2348         else if (IS_HARDWARE_TYPE_JAGUAR(pAdapter)) {
2349 #if ((RTL8812A_SUPPORT==1) || (RTL8821A_SUPPORT == 1))
2350                 txPower = PHY_GetTxPowerIndex_8812A(pAdapter, RFPath, Rate, BandWidth, Channel);
2351 #endif
2352         }
2353         else if (IS_HARDWARE_TYPE_8723B(pAdapter)) {
2354 #if (RTL8723B_SUPPORT==1)
2355                 txPower = PHY_GetTxPowerIndex_8723B(pAdapter, RFPath, Rate, BandWidth, Channel);
2356 #endif
2357         }
2358         else if (IS_HARDWARE_TYPE_8192E(pAdapter)) {
2359 #if (RTL8192E_SUPPORT==1)
2360                 txPower = PHY_GetTxPowerIndex_8192E(pAdapter, RFPath, Rate, BandWidth, Channel);
2361 #endif
2362         }
2363         else if (IS_HARDWARE_TYPE_8188E(pAdapter)) {
2364 #if (RTL8188E_SUPPORT==1)
2365                 txPower = PHY_GetTxPowerIndex_8188E(pAdapter, RFPath, Rate, BandWidth, Channel);
2366 #endif
2367         }
2368
2369         return txPower;
2370 }
2371
2372 VOID
2373 PHY_SetTxPowerIndex(
2374         IN      PADAPTER                pAdapter,
2375         IN      u32                             PowerIndex,
2376         IN      u8                              RFPath,
2377         IN      u8                              Rate
2378         )
2379 {
2380         if (IS_HARDWARE_TYPE_8813A(pAdapter)) {
2381 //#if (RTL8813A_SUPPORT==1)
2382 //              PHY_SetTxPowerIndex_8813A( pAdapter, PowerIndex, RFPath, Rate );
2383 //#endif
2384         }
2385         else if (IS_HARDWARE_TYPE_JAGUAR(pAdapter)) {
2386 #if ((RTL8812A_SUPPORT==1) || (RTL8821A_SUPPORT == 1))
2387                 PHY_SetTxPowerIndex_8812A( pAdapter, PowerIndex, RFPath, Rate );
2388 #endif
2389         }
2390         else if (IS_HARDWARE_TYPE_8723B(pAdapter)) {
2391 #if (RTL8723B_SUPPORT==1)
2392                 PHY_SetTxPowerIndex_8723B( pAdapter, PowerIndex, RFPath, Rate );
2393 #endif
2394         }
2395         else if (IS_HARDWARE_TYPE_8192E(pAdapter)) {
2396 #if (RTL8192E_SUPPORT==1)
2397                 PHY_SetTxPowerIndex_8192E( pAdapter, PowerIndex, RFPath, Rate );
2398 #endif
2399         }
2400         else if (IS_HARDWARE_TYPE_8188E(pAdapter)) {
2401 #if (RTL8188E_SUPPORT==1)
2402                 PHY_SetTxPowerIndex_8188E( pAdapter, PowerIndex, RFPath, Rate );
2403 #endif
2404         }
2405 }
2406
2407 VOID
2408 Hal_ChannelPlanToRegulation(
2409         IN      PADAPTER                Adapter,
2410         IN      u16                             ChannelPlan
2411         )
2412 {
2413         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
2414         pHalData->Regulation2_4G = TXPWR_LMT_WW;
2415         pHalData->Regulation5G = TXPWR_LMT_WW;
2416
2417         switch(ChannelPlan)
2418         {
2419                 case RT_CHANNEL_DOMAIN_WORLD_NULL:
2420                         pHalData->Regulation2_4G = TXPWR_LMT_WW;
2421                         break;
2422                 case RT_CHANNEL_DOMAIN_ETSI1_NULL:
2423                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2424                         break;
2425                 case RT_CHANNEL_DOMAIN_FCC1_NULL:
2426                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2427                         break;
2428                 case RT_CHANNEL_DOMAIN_MKK1_NULL:
2429                         pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2430                         break;
2431                 case RT_CHANNEL_DOMAIN_ETSI2_NULL:
2432                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2433                         break;
2434                 case RT_CHANNEL_DOMAIN_FCC1_FCC1:
2435                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2436                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2437                         break;
2438                 case RT_CHANNEL_DOMAIN_WORLD_ETSI1:
2439                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2440                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2441                         break;
2442                 case RT_CHANNEL_DOMAIN_MKK1_MKK1:
2443                         pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2444                         pHalData->Regulation5G = TXPWR_LMT_MKK;
2445                         break;
2446                 case RT_CHANNEL_DOMAIN_WORLD_KCC1:
2447                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2448                         pHalData->Regulation5G = TXPWR_LMT_MKK;
2449                         break;
2450                 case RT_CHANNEL_DOMAIN_WORLD_FCC2:
2451                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2452                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2453                                         break;
2454                 case RT_CHANNEL_DOMAIN_WORLD_FCC3:
2455                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2456                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2457                         break;
2458                 case RT_CHANNEL_DOMAIN_WORLD_FCC4:
2459                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2460                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2461                         break;
2462                 case RT_CHANNEL_DOMAIN_WORLD_FCC5:
2463                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2464                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2465                         break;
2466                 case RT_CHANNEL_DOMAIN_WORLD_FCC6:
2467                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2468                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2469                         break;
2470                 case RT_CHANNEL_DOMAIN_FCC1_FCC7:
2471                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2472                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2473                         break;
2474                 case RT_CHANNEL_DOMAIN_WORLD_ETSI2:
2475                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2476                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2477                         break;
2478                 case RT_CHANNEL_DOMAIN_WORLD_ETSI3:
2479                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2480                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2481                         break;
2482                 case RT_CHANNEL_DOMAIN_MKK1_MKK2:
2483                         pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2484                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2485                         break;
2486                 case RT_CHANNEL_DOMAIN_MKK1_MKK3:
2487                         pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2488                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2489                         break;
2490                 case RT_CHANNEL_DOMAIN_FCC1_NCC1:
2491                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2492                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2493                         break;
2494                 case RT_CHANNEL_DOMAIN_FCC1_NCC2:
2495                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2496                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2497                         break;
2498                 case RT_CHANNEL_DOMAIN_GLOBAL_NULL:
2499                         pHalData->Regulation2_4G = TXPWR_LMT_WW;
2500                         pHalData->Regulation5G = TXPWR_LMT_WW;
2501                         break;
2502                 case RT_CHANNEL_DOMAIN_ETSI1_ETSI4:
2503                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2504                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2505                         break;
2506                 case RT_CHANNEL_DOMAIN_FCC1_FCC2:
2507                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2508                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2509                         break;
2510                 case RT_CHANNEL_DOMAIN_FCC1_NCC3:
2511                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2512                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2513                         break;
2514                 case RT_CHANNEL_DOMAIN_WORLD_ETSI5:
2515                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2516                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2517                         break;
2518                 case RT_CHANNEL_DOMAIN_FCC1_FCC8:
2519                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2520                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2521                         break;
2522                 case RT_CHANNEL_DOMAIN_WORLD_ETSI6:
2523                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2524                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2525                         break;
2526                 case RT_CHANNEL_DOMAIN_WORLD_ETSI7:
2527                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2528                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2529                         break;
2530                 case RT_CHANNEL_DOMAIN_WORLD_ETSI8:
2531                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2532                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2533                         break;
2534                 case RT_CHANNEL_DOMAIN_WORLD_ETSI9:
2535                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2536                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2537                         break;
2538                 case RT_CHANNEL_DOMAIN_WORLD_ETSI10:
2539                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2540                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2541                         break;
2542                 case RT_CHANNEL_DOMAIN_WORLD_ETSI11:
2543                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2544                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2545                         break;
2546                 case RT_CHANNEL_DOMAIN_FCC1_NCC4:
2547                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2548                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2549                         break;
2550                 case RT_CHANNEL_DOMAIN_WORLD_ETSI12:
2551                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2552                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2553                         break;
2554                 case RT_CHANNEL_DOMAIN_FCC1_FCC9:
2555                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2556                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2557                         break;
2558                 case RT_CHANNEL_DOMAIN_WORLD_ETSI13:
2559                         pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2560                         pHalData->Regulation5G = TXPWR_LMT_ETSI;
2561                         break;
2562                 case RT_CHANNEL_DOMAIN_FCC1_FCC10:
2563                         pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2564                         pHalData->Regulation5G = TXPWR_LMT_FCC;
2565                         break;
2566                 case RT_CHANNEL_DOMAIN_REALTEK_DEFINE: //Realtek Reserve
2567                         pHalData->Regulation2_4G = TXPWR_LMT_WW;
2568                         pHalData->Regulation5G = TXPWR_LMT_WW;
2569                         break;
2570                 default:
2571                         break;
2572         }
2573 }
2574
2575 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
2576
2577 extern char *rtw_phy_file_path;
2578 char    file_path[PATH_LENGTH_MAX];
2579
2580 #define GetLineFromBuffer(buffer)        strsep(&buffer, "\n")
2581
2582 int
2583 phy_ConfigMACWithParaFile(
2584         IN      PADAPTER        Adapter,
2585         IN      char*           pFileName
2586 )
2587 {
2588         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(Adapter);
2589         int     rlen = 0, rtStatus = _FAIL;
2590         char    *szLine, *ptmp;
2591         u32     u4bRegOffset, u4bRegValue, u4bMove;
2592
2593         if(!(Adapter->registrypriv.load_phy_file & LOAD_MAC_PARA_FILE))
2594                 return rtStatus;
2595
2596         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2597
2598         if ((pHalData->mac_reg_len == 0) && (pHalData->mac_reg == NULL))
2599         {
2600                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
2601
2602                 if (rtw_is_file_readable(file_path) == _TRUE)
2603                 {
2604                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2605                         if (rlen > 0)
2606                         {
2607                                 rtStatus = _SUCCESS;
2608                                 pHalData->mac_reg = rtw_zmalloc(rlen);
2609                                 if(pHalData->mac_reg) {
2610                                         _rtw_memcpy(pHalData->mac_reg, pHalData->para_file_buf, rlen);
2611                                         pHalData->mac_reg_len = rlen;
2612                                 }
2613                                 else {
2614                                         DBG_871X("%s mac_reg alloc fail !\n",__FUNCTION__);
2615                                 }
2616                         }
2617                 }
2618         }
2619         else
2620         {
2621                 if ((pHalData->mac_reg_len != 0) && (pHalData->mac_reg != NULL)) {
2622                         _rtw_memcpy(pHalData->para_file_buf, pHalData->mac_reg, pHalData->mac_reg_len);
2623                         rtStatus = _SUCCESS;
2624                 }
2625                 else {
2626                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
2627                 }
2628         }
2629
2630         if (rtStatus == _SUCCESS)
2631         {
2632                 ptmp = pHalData->para_file_buf;
2633                 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
2634                 {
2635                         if(!IsCommentString(szLine))
2636                         {
2637                                 // Get 1st hex value as register offset
2638                                 if(GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove))
2639                                 {
2640                                         if(u4bRegOffset == 0xffff)
2641                                         { // Ending.
2642                                                 break;
2643                                         }
2644
2645                                         // Get 2nd hex value as register value.
2646                                         szLine += u4bMove;
2647                                         if(GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
2648                                         {
2649                                                 rtw_write8(Adapter, u4bRegOffset, (u8)u4bRegValue);
2650                                         }
2651                                 }
2652                         }
2653                 }
2654         }
2655         else
2656         {
2657                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
2658         }
2659
2660         return rtStatus;
2661 }
2662
2663 int
2664 phy_ConfigBBWithParaFile(
2665         IN      PADAPTER        Adapter,
2666         IN      char*           pFileName,
2667         IN      u32                     ConfigType
2668 )
2669 {
2670         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
2671         int     rlen = 0, rtStatus = _FAIL;
2672         char    *szLine, *ptmp;
2673         u32     u4bRegOffset, u4bRegValue, u4bMove;
2674         char    *pBuf = NULL;
2675         u32     *pBufLen = NULL;
2676
2677         if(!(Adapter->registrypriv.load_phy_file & LOAD_BB_PARA_FILE))
2678                 return rtStatus;
2679
2680         switch(ConfigType)
2681         {
2682                 case CONFIG_BB_PHY_REG:
2683                         pBuf = pHalData->bb_phy_reg;
2684                         pBufLen = &pHalData->bb_phy_reg_len;
2685                         break;
2686                 case CONFIG_BB_AGC_TAB:
2687                         pBuf = pHalData->bb_agc_tab;
2688                         pBufLen = &pHalData->bb_agc_tab_len;
2689                         break;
2690                 default:
2691                         DBG_871X("Unknown ConfigType!! %d\r\n", ConfigType);
2692                         break;
2693         }
2694
2695         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2696
2697         if ((*pBufLen == 0) && (pBuf == NULL))
2698         {
2699                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
2700
2701                 if (rtw_is_file_readable(file_path) == _TRUE)
2702                 {
2703                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2704                         if (rlen > 0)
2705                         {
2706                                 rtStatus = _SUCCESS;
2707                                 pBuf = rtw_zmalloc(rlen);
2708                                 if(pBuf) {
2709                                         _rtw_memcpy(pBuf, pHalData->para_file_buf, rlen);
2710                                         *pBufLen = rlen;
2711
2712                                         switch(ConfigType)
2713                                         {
2714                                                 case CONFIG_BB_PHY_REG:
2715                                                         pHalData->bb_phy_reg = pBuf;
2716                                                         break;
2717                                                 case CONFIG_BB_AGC_TAB:
2718                                                         pHalData->bb_agc_tab = pBuf;
2719                                                         break;
2720                                                 default:
2721                                                         DBG_871X("Unknown ConfigType!! %d\r\n", ConfigType);
2722                                                         rtw_mfree(pBuf, rlen);
2723                                                         break;
2724                                         }
2725                                 }
2726                                 else {
2727                                         DBG_871X("%s(): ConfigType %d  alloc fail !\n",__FUNCTION__,ConfigType);
2728                                 }
2729                         }
2730                 }
2731         }
2732         else
2733         {
2734                 if ((*pBufLen != 0) && (pBuf != NULL)) {
2735                         _rtw_memcpy(pHalData->para_file_buf, pBuf, *pBufLen);
2736                         rtStatus = _SUCCESS;
2737                 }
2738                 else {
2739                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
2740                 }
2741         }
2742
2743         if (rtStatus == _SUCCESS)
2744         {
2745                 ptmp = pHalData->para_file_buf;
2746                 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
2747                 {
2748                         if(!IsCommentString(szLine))
2749                         {
2750                                 // Get 1st hex value as register offset.
2751                                 if(GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove))
2752                                 {
2753                                         if(u4bRegOffset == 0xffff)
2754                                         { // Ending.
2755                                                 break;
2756                                         }
2757                                         else if (u4bRegOffset == 0xfe || u4bRegOffset == 0xffe)
2758                                         {
2759                                                 #ifdef CONFIG_LONG_DELAY_ISSUE
2760                                                 rtw_msleep_os(50);
2761                                                 #else
2762                                                 rtw_mdelay_os(50);
2763                                                 #endif
2764                                         }
2765                                         else if (u4bRegOffset == 0xfd)
2766                                         {
2767                                                 rtw_mdelay_os(5);
2768                                         }
2769                                         else if (u4bRegOffset == 0xfc)
2770                                         {
2771                                                 rtw_mdelay_os(1);
2772                                         }
2773                                         else if (u4bRegOffset == 0xfb)
2774                                         {
2775                                                 rtw_udelay_os(50);
2776                                         }
2777                                         else if (u4bRegOffset == 0xfa)
2778                                         {
2779                                                 rtw_udelay_os(5);
2780                                         }
2781                                         else if (u4bRegOffset == 0xf9)
2782                                         {
2783                                                 rtw_udelay_os(1);
2784                                         }
2785
2786                                         // Get 2nd hex value as register value.
2787                                         szLine += u4bMove;
2788                                         if(GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
2789                                         {
2790                                                 //DBG_871X("[BB-ADDR]%03lX=%08lX\n", u4bRegOffset, u4bRegValue);
2791                                                 PHY_SetBBReg(Adapter, u4bRegOffset, bMaskDWord, u4bRegValue);
2792
2793                                                 if (u4bRegOffset == 0xa24)
2794                                                         pHalData->odmpriv.RFCalibrateInfo.RegA24 = u4bRegValue;
2795
2796                                                 // Add 1us delay between BB/RF register setting.
2797                                                 rtw_udelay_os(1);
2798                                         }
2799                                 }
2800                         }
2801                 }
2802         }
2803         else
2804         {
2805                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
2806         }
2807
2808         return rtStatus;
2809 }
2810
2811 VOID
2812 phy_DecryptBBPgParaFile(
2813         PADAPTER                Adapter,
2814         char*                   buffer
2815         )
2816 {
2817         u32     i = 0, j = 0;
2818         u8      map[95] = {0};
2819         u8      currentChar;
2820         char    *BufOfLines, *ptmp;
2821
2822         //DBG_871X("=====>phy_DecryptBBPgParaFile()\n");
2823         // 32 the ascii code of the first visable char, 126 the last one
2824         for ( i = 0; i < 95; ++i )
2825                 map[i] = ( u8 ) ( 94 - i );
2826
2827         ptmp = buffer;
2828         i = 0;
2829         for (BufOfLines = GetLineFromBuffer(ptmp); BufOfLines != NULL; BufOfLines = GetLineFromBuffer(ptmp))
2830         {
2831                 //DBG_871X("Encrypted Line: %s\n", BufOfLines);
2832
2833                 for ( j = 0; j < strlen(BufOfLines); ++j )
2834                 {
2835                         currentChar = BufOfLines[j];
2836
2837                         if ( currentChar == '\0' )
2838                                 break;
2839
2840                         currentChar -=  (u8) ( ( ( ( i + j ) * 3 ) % 128 ) );
2841
2842                         BufOfLines[j] = map[currentChar - 32] + 32;
2843                 }
2844                 //DBG_871X("Decrypted Line: %s\n", BufOfLines );
2845                 if (strlen(BufOfLines) != 0)
2846                         i++;
2847                 BufOfLines[strlen(BufOfLines)] = '\n';
2848         }
2849 }
2850
2851 int
2852 phy_ParseBBPgParaFile(
2853         PADAPTER                Adapter,
2854         char*                   buffer
2855         )
2856 {
2857         int     rtStatus = _SUCCESS;
2858         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
2859         char    *szLine, *ptmp;
2860         u32     u4bRegOffset, u4bRegMask, u4bRegValue;
2861         u32     u4bMove;
2862         BOOLEAN firstLine = _TRUE;
2863         u8      tx_num = 0;
2864         u8      band = 0, rf_path = 0;
2865
2866         //DBG_871X("=====>phy_ParseBBPgParaFile()\n");
2867
2868         if ( Adapter->registrypriv.RegDecryptCustomFile == 1 )
2869                 phy_DecryptBBPgParaFile( Adapter, buffer);
2870
2871         ptmp = buffer;
2872         for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
2873         {
2874                 if(!IsCommentString(szLine))
2875                 {
2876                         if( isAllSpaceOrTab( szLine, sizeof( szLine ) ) )
2877                                 continue;
2878
2879                         // Get header info (relative value or exact value)
2880                         if ( firstLine )
2881                         {
2882                                 if ( eqNByte( szLine, (u8 *)("#[v1]"), 5 ) )
2883                                 {
2884
2885                                         pHalData->odmpriv.PhyRegPgVersion = szLine[3] - '0';
2886                                         //DBG_871X("This is a new format PHY_REG_PG.txt \n");
2887                                 }
2888                                 else if ( eqNByte( szLine, (u8 *)("#[v0]"), 5 ))
2889                                 {
2890                                         pHalData->odmpriv.PhyRegPgVersion = szLine[3] - '0';
2891                                         //DBG_871X("This is a old format PHY_REG_PG.txt ok\n");
2892                                 }
2893                                 else
2894                                 {
2895                                         DBG_871X("The format in PHY_REG_PG are invalid %s\n", szLine);
2896                                         return _FAIL;
2897                                 }
2898
2899                                 if ( eqNByte( szLine + 5, (u8 *)("[Exact]#"), 8 ) )
2900                                 {
2901                                         pHalData->odmpriv.PhyRegPgValueType = PHY_REG_PG_EXACT_VALUE;
2902                                         //DBG_871X("The values in PHY_REG_PG are exact values ok\n");
2903                                         firstLine = _FALSE;
2904                                         continue;
2905                                 }
2906                                 else if ( eqNByte( szLine + 5, (pu1Byte)("[Relative]#"), 11 ) )
2907                                 {
2908                                         pHalData->odmpriv.PhyRegPgValueType = PHY_REG_PG_RELATIVE_VALUE;
2909                                         //DBG_871X("The values in PHY_REG_PG are relative values ok\n");
2910                                         firstLine = _FALSE;
2911                                         continue;
2912                                 }
2913                                 else
2914                                 {
2915                                         DBG_871X("The values in PHY_REG_PG are invalid %s\n", szLine);
2916                                         return _FAIL;
2917                                 }
2918                         }
2919
2920                         if ( pHalData->odmpriv.PhyRegPgVersion == 0 )
2921                         {
2922                                 // Get 1st hex value as register offset.
2923                                 if(GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove))
2924                                 {
2925                                         szLine += u4bMove;
2926                                         if(u4bRegOffset == 0xffff)
2927                                         { // Ending.
2928                                                 break;
2929                                         }
2930
2931                                         // Get 2nd hex value as register mask.
2932                                         if ( GetHexValueFromString(szLine, &u4bRegMask, &u4bMove) )
2933                                                 szLine += u4bMove;
2934                                         else
2935                                                 return _FAIL;
2936
2937                                         if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_RELATIVE_VALUE )
2938                                         {
2939                                                 // Get 3rd hex value as register value.
2940                                                 if(GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
2941                                                 {
2942                                                         PHY_StoreTxPowerByRate(Adapter, 0, 0, 1, u4bRegOffset, u4bRegMask, u4bRegValue);
2943                                                         //DBG_871X("[ADDR] %03X=%08X Mask=%08x\n", u4bRegOffset, u4bRegValue, u4bRegMask);
2944                                                 }
2945                                                 else
2946                                                 {
2947                                                         return _FAIL;
2948                                                 }
2949                                         }
2950                                         else if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE )
2951                                         {
2952                                                 u32     combineValue = 0;
2953                                                 u8      integer = 0, fraction = 0;
2954
2955                                                 if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
2956                                                         szLine += u4bMove;
2957                                                 else
2958                                                         return _FAIL;
2959
2960                                                 integer *= 2;
2961                                                 if ( fraction == 5 ) integer += 1;
2962                                                 combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
2963                                                 //DBG_871X(" %d", integer );
2964
2965                                                 if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
2966                                                         szLine += u4bMove;
2967                                                 else
2968                                                         return _FAIL;
2969
2970                                                 integer *= 2;
2971                                                 if ( fraction == 5 ) integer += 1;
2972                                                 combineValue <<= 8;
2973                                                 combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
2974                                                 //DBG_871X(" %d", integer );
2975
2976                                                 if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
2977                                                         szLine += u4bMove;
2978                                                 else
2979                                                         return _FAIL;
2980
2981                                                 integer *= 2;
2982                                                 if ( fraction == 5 ) integer += 1;
2983                                                 combineValue <<= 8;
2984                                                 combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
2985                                                 //DBG_871X(" %d", integer );
2986
2987                                                 if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
2988                                                         szLine += u4bMove;
2989                                                 else
2990                                                         return _FAIL;
2991
2992                                                 integer *= 2;
2993                                                 if ( fraction == 5 ) integer += 1;
2994                                                 combineValue <<= 8;
2995                                                 combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
2996                                                 //DBG_871X(" %d", integer );
2997                                                 PHY_StoreTxPowerByRate(Adapter, 0, 0, 1, u4bRegOffset, u4bRegMask, combineValue);
2998
2999                                                 //DBG_871X("[ADDR] 0x%3x = 0x%4x\n", u4bRegOffset, combineValue );
3000                                         }
3001                                 }
3002                         }
3003                         else if ( pHalData->odmpriv.PhyRegPgVersion > 0 )
3004                         {
3005                                 u32     index = 0, cnt = 0;
3006
3007                                 if ( eqNByte( szLine, "0xffff", 6 ) )
3008                                         break;
3009
3010                                 if( !eqNByte( "#[END]#", szLine, 7 ) )
3011                                 {
3012                                         // load the table label info
3013                                         if ( szLine[0] == '#' )
3014                                         {
3015                                                 index = 0;
3016                                                 if ( eqNByte( szLine, "#[2.4G]" , 7 ) )
3017                                                 {
3018                                                         band = BAND_ON_2_4G;
3019                                                         index += 8;
3020                                                 }
3021                                                 else if ( eqNByte( szLine, "#[5G]", 5) )
3022                                                 {
3023                                                         band = BAND_ON_5G;
3024                                                         index += 6;
3025                                                 }
3026                                                 else
3027                                                 {
3028                                                         DBG_871X("Invalid band %s in PHY_REG_PG.txt \n", szLine );
3029                                                         return _FAIL;
3030                                                 }
3031
3032                                                 rf_path= szLine[index] - 'A';
3033                                                 //DBG_871X(" Table label Band %d, RfPath %d\n", band, rf_path );
3034                                         }
3035                                         else // load rows of tables
3036                                         {
3037                                                 if ( szLine[1] == '1' )
3038                                                         tx_num = RF_1TX;
3039                                                 else if ( szLine[1] == '2' )
3040                                                         tx_num = RF_2TX;
3041                                                 else if ( szLine[1] == '3' )
3042                                                         tx_num = RF_3TX;
3043                                                 else if ( szLine[1] == '4' )
3044                                                         tx_num = RF_4TX;
3045                                                 else
3046                                                 {
3047                                                         DBG_871X("Invalid row in PHY_REG_PG.txt %c\n", szLine[1] );
3048                                                         return _FAIL;
3049                                                 }
3050
3051                                                 while ( szLine[index] != ']' )
3052                                                         ++index;
3053                                                 ++index;// skip ]
3054
3055                                                 // Get 2nd hex value as register offset.
3056                                                 szLine += index;
3057                                                 if ( GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove) )
3058                                                         szLine += u4bMove;
3059                                                 else
3060                                                         return _FAIL;
3061
3062                                                 // Get 2nd hex value as register mask.
3063                                                 if ( GetHexValueFromString(szLine, &u4bRegMask, &u4bMove) )
3064                                                         szLine += u4bMove;
3065                                                 else
3066                                                         return _FAIL;
3067
3068                                                 if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_RELATIVE_VALUE )
3069                                                 {
3070                                                         // Get 3rd hex value as register value.
3071                                                         if(GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
3072                                                         {
3073                                                                 PHY_StoreTxPowerByRate(Adapter, band, rf_path, tx_num, u4bRegOffset, u4bRegMask, u4bRegValue);
3074                                                                 //DBG_871X("[ADDR] %03X (tx_num %d) =%08X Mask=%08x\n", u4bRegOffset, tx_num, u4bRegValue, u4bRegMask);
3075                                                         }
3076                                                         else
3077                                                         {
3078                                                                 return _FAIL;
3079                                                         }
3080                                                 }
3081                                                 else if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE )
3082                                                 {
3083                                                         u32     combineValue = 0;
3084                                                         u8      integer = 0, fraction = 0;
3085
3086                                                         if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
3087                                                                 szLine += u4bMove;
3088                                                         else
3089                                                                 return _FAIL;
3090
3091                                                         integer *= 2;
3092                                                         if ( fraction == 5 ) integer += 1;
3093                                                         combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
3094                                                         //DBG_871X(" %d", integer );
3095
3096                                                         if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
3097                                                                 szLine += u4bMove;
3098                                                         else
3099                                                                 return _FAIL;
3100
3101                                                         integer *= 2;
3102                                                         if ( fraction == 5 ) integer += 1;
3103                                                         combineValue <<= 8;
3104                                                         combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
3105                                                         //DBG_871X(" %d", integer );
3106
3107                                                         if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
3108                                                                 szLine += u4bMove;
3109                                                         else
3110                                                                 return _FAIL;
3111
3112                                                         integer *= 2;
3113                                                         if ( fraction == 5 ) integer += 1;
3114                                                         combineValue <<= 8;
3115                                                         combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
3116                                                         //DBG_871X(" %d", integer );
3117
3118                                                         if ( GetFractionValueFromString( szLine, &integer, &fraction, &u4bMove ) )
3119                                                                 szLine += u4bMove;
3120                                                         else
3121                                                                 return _FAIL;
3122
3123                                                         integer *= 2;
3124                                                         if ( fraction == 5 ) integer += 1;
3125                                                         combineValue <<= 8;
3126                                                         combineValue |= ( ( ( integer / 10 ) << 4 ) + ( integer % 10 ) );
3127                                                         //DBG_871X(" %d", integer );
3128                                                         PHY_StoreTxPowerByRate(Adapter, band, rf_path, tx_num, u4bRegOffset, u4bRegMask, combineValue);
3129
3130                                                         //DBG_871X("[ADDR] 0x%3x (tx_num %d) = 0x%4x\n", u4bRegOffset, tx_num, combineValue );
3131                                                 }
3132                                         }
3133                                 }
3134                         }
3135                 }
3136         }
3137         //DBG_871X("<=====phy_ParseBBPgParaFile()\n");
3138         return rtStatus;
3139 }
3140
3141 int
3142 phy_ConfigBBWithPgParaFile(
3143         IN      PADAPTER        Adapter,
3144         IN      char*           pFileName)
3145 {
3146         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
3147         int     rlen = 0, rtStatus = _FAIL;
3148
3149         if(!(Adapter->registrypriv.load_phy_file & LOAD_BB_PG_PARA_FILE))
3150                 return rtStatus;
3151
3152         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
3153
3154         if ((pHalData->bb_phy_reg_pg_len == 0) && (pHalData->bb_phy_reg_pg == NULL))
3155         {
3156                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
3157
3158                 if (rtw_is_file_readable(file_path) == _TRUE)
3159                 {
3160                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
3161                         if (rlen > 0)
3162                         {
3163                                 rtStatus = _SUCCESS;
3164                                 pHalData->bb_phy_reg_pg = rtw_zmalloc(rlen);
3165                                 if(pHalData->bb_phy_reg_pg) {
3166                                         _rtw_memcpy(pHalData->bb_phy_reg_pg, pHalData->para_file_buf, rlen);
3167                                         pHalData->bb_phy_reg_pg_len = rlen;
3168                                 }
3169                                 else {
3170                                         DBG_871X("%s bb_phy_reg_pg alloc fail !\n",__FUNCTION__);
3171                                 }
3172                         }
3173                 }
3174         }
3175         else
3176         {
3177                 if ((pHalData->bb_phy_reg_pg_len != 0) && (pHalData->bb_phy_reg_pg != NULL)) {
3178                         _rtw_memcpy(pHalData->para_file_buf, pHalData->bb_phy_reg_pg, pHalData->bb_phy_reg_pg_len);
3179                         rtStatus = _SUCCESS;
3180                 }
3181                 else {
3182                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
3183                 }
3184         }
3185
3186         if(rtStatus == _SUCCESS)
3187         {
3188                 //DBG_871X("phy_ConfigBBWithPgParaFile(): read %s ok\n", pFileName);
3189                 phy_ParseBBPgParaFile(Adapter, pHalData->para_file_buf);
3190         }
3191         else
3192         {
3193                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
3194         }
3195
3196         return rtStatus;
3197 }
3198
3199 #if (MP_DRIVER == 1 )
3200
3201 int
3202 phy_ConfigBBWithMpParaFile(
3203         IN      PADAPTER        Adapter,
3204         IN      char*           pFileName
3205 )
3206 {
3207         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
3208         int     rlen = 0, rtStatus = _FAIL;
3209         char    *szLine, *ptmp;
3210         u32     u4bRegOffset, u4bRegValue, u4bMove;
3211
3212         if(!(Adapter->registrypriv.load_phy_file & LOAD_BB_MP_PARA_FILE))
3213                 return rtStatus;
3214
3215         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
3216
3217         if ((pHalData->bb_phy_reg_mp_len == 0) && (pHalData->bb_phy_reg_mp == NULL))
3218         {
3219                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
3220
3221                 if (rtw_is_file_readable(file_path) == _TRUE)
3222                 {
3223                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
3224                         if (rlen > 0)
3225                         {
3226                                 rtStatus = _SUCCESS;
3227                                 pHalData->bb_phy_reg_mp = rtw_zmalloc(rlen);
3228                                 if(pHalData->bb_phy_reg_mp) {
3229                                         _rtw_memcpy(pHalData->bb_phy_reg_mp, pHalData->para_file_buf, rlen);
3230                                         pHalData->bb_phy_reg_mp_len = rlen;
3231                                 }
3232                                 else {
3233                                         DBG_871X("%s bb_phy_reg_mp alloc fail !\n",__FUNCTION__);
3234                                 }
3235                         }
3236                 }
3237         }
3238         else
3239         {
3240                 if ((pHalData->bb_phy_reg_mp_len != 0) && (pHalData->bb_phy_reg_mp != NULL)) {
3241                         _rtw_memcpy(pHalData->para_file_buf, pHalData->bb_phy_reg_mp, pHalData->bb_phy_reg_mp_len);
3242                         rtStatus = _SUCCESS;
3243                 }
3244                 else {
3245                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
3246                 }
3247         }
3248
3249         if(rtStatus == _SUCCESS)
3250         {
3251                 //DBG_871X("phy_ConfigBBWithMpParaFile(): read %s ok\n", pFileName);
3252
3253                 ptmp = pHalData->para_file_buf;
3254                 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
3255                 {
3256                         if(!IsCommentString(szLine))
3257                         {
3258                                 // Get 1st hex value as register offset.
3259                                 if(GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove))
3260                                 {
3261                                         if(u4bRegOffset == 0xffff)
3262                                         { // Ending.
3263                                                 break;
3264                                         }
3265                                         else if (u4bRegOffset == 0xfe || u4bRegOffset == 0xffe)
3266                                         {
3267                                                 #ifdef CONFIG_LONG_DELAY_ISSUE
3268                                                 rtw_msleep_os(50);
3269                                                 #else
3270                                                 rtw_mdelay_os(50);
3271                                                 #endif
3272                                         }
3273                                         else if (u4bRegOffset == 0xfd)
3274                                         {
3275                                                 rtw_mdelay_os(5);
3276                                         }
3277                                         else if (u4bRegOffset == 0xfc)
3278                                         {
3279                                                 rtw_mdelay_os(1);
3280                                         }
3281                                         else if (u4bRegOffset == 0xfb)
3282                                         {
3283                                                 rtw_udelay_os(50);
3284                                         }
3285                                         else if (u4bRegOffset == 0xfa)
3286                                         {
3287                                                 rtw_udelay_os(5);
3288                                         }
3289                                         else if (u4bRegOffset == 0xf9)
3290                                         {
3291                                                 rtw_udelay_os(1);
3292                                         }
3293
3294                                         // Get 2nd hex value as register value.
3295                                         szLine += u4bMove;
3296                                         if(GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
3297                                         {
3298                                                 //DBG_871X("[ADDR]%03lX=%08lX\n", u4bRegOffset, u4bRegValue);
3299                                                 PHY_SetBBReg(Adapter, u4bRegOffset, bMaskDWord, u4bRegValue);
3300
3301                                                 // Add 1us delay between BB/RF register setting.
3302                                                 rtw_udelay_os(1);
3303                                         }
3304                                 }
3305                         }
3306                 }
3307         }
3308         else
3309         {
3310                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
3311         }
3312
3313         return rtStatus;
3314 }
3315
3316 #endif
3317
3318 int
3319 PHY_ConfigRFWithParaFile(
3320         IN      PADAPTER        Adapter,
3321         IN      char*           pFileName,
3322         IN      u8                      eRFPath
3323 )
3324 {
3325         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
3326         int     rlen = 0, rtStatus = _FAIL;
3327         char    *szLine, *ptmp;
3328         u32     u4bRegOffset, u4bRegValue, u4bMove;
3329         u16     i;
3330         char    *pBuf = NULL;
3331         u32     *pBufLen = NULL;
3332
3333         if(!(Adapter->registrypriv.load_phy_file & LOAD_RF_PARA_FILE))
3334                 return rtStatus;
3335
3336         switch(eRFPath)
3337         {
3338                 case ODM_RF_PATH_A:
3339                         pBuf = pHalData->rf_radio_a;
3340                         pBufLen = &pHalData->rf_radio_a_len;
3341                         break;
3342                 case ODM_RF_PATH_B:
3343                         pBuf = pHalData->rf_radio_b;
3344                         pBufLen = &pHalData->rf_radio_b_len;
3345                         break;
3346                 default:
3347                         DBG_871X("Unknown RF path!! %d\r\n", eRFPath);
3348                         break;
3349         }
3350
3351         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
3352
3353         if ((*pBufLen == 0) && (pBuf == NULL))
3354         {
3355                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
3356
3357                 if (rtw_is_file_readable(file_path) == _TRUE)
3358                 {
3359                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
3360                         if (rlen > 0)
3361                         {
3362                                 rtStatus = _SUCCESS;
3363                                 pBuf = rtw_zmalloc(rlen);
3364                                 if(pBuf) {
3365                                         _rtw_memcpy(pBuf, pHalData->para_file_buf, rlen);
3366                                         *pBufLen = rlen;
3367
3368                                         switch(eRFPath)
3369                                         {
3370                                                 case ODM_RF_PATH_A:
3371                                                         pHalData->rf_radio_a = pBuf;
3372                                                         break;
3373                                                 case ODM_RF_PATH_B:
3374                                                         pHalData->rf_radio_b = pBuf;
3375                                                         break;
3376                                                 default:
3377                                                         DBG_871X("Unknown eRFPath!! %d\r\n", eRFPath);
3378                                                         rtw_mfree(pBuf, rlen);
3379                                                         break;
3380                                         }
3381                                 }
3382                                 else {
3383                                         DBG_871X("%s(): eRFPath=%d  alloc fail !\n",__FUNCTION__,eRFPath);
3384                                 }
3385                         }
3386                 }
3387         }
3388         else
3389         {
3390                 if ((*pBufLen != 0) && (pBuf != NULL)) {
3391                         _rtw_memcpy(pHalData->para_file_buf, pBuf, *pBufLen);
3392                         rtStatus = _SUCCESS;
3393                 }
3394                 else {
3395                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
3396                 }
3397         }
3398
3399         if(rtStatus == _SUCCESS)
3400         {
3401                 //DBG_871X("%s(): read %s successfully\n", __FUNCTION__, pFileName);
3402
3403                 ptmp = pHalData->para_file_buf;
3404                 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
3405                 {
3406                         if(!IsCommentString(szLine))
3407                         {
3408                                 // Get 1st hex value as register offset.
3409                                 if(GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove))
3410                                 {
3411                                         if(u4bRegOffset == 0xfe || u4bRegOffset == 0xffe)
3412                                         { // Deay specific ms. Only RF configuration require delay.
3413                                                 #ifdef CONFIG_LONG_DELAY_ISSUE
3414                                                 rtw_msleep_os(50);
3415                                                 #else
3416                                                 rtw_mdelay_os(50);
3417                                                 #endif
3418                                         }
3419                                         else if (u4bRegOffset == 0xfd)
3420                                         {
3421                                                 //delay_ms(5);
3422                                                 for(i=0;i<100;i++)
3423                                                         rtw_udelay_os(MAX_STALL_TIME);
3424                                         }
3425                                         else if (u4bRegOffset == 0xfc)
3426                                         {
3427                                                 //delay_ms(1);
3428                                                 for(i=0;i<20;i++)
3429                                                         rtw_udelay_os(MAX_STALL_TIME);
3430                                         }
3431                                         else if (u4bRegOffset == 0xfb)
3432                                         {
3433                                                 rtw_udelay_os(50);
3434                                         }
3435                                         else if (u4bRegOffset == 0xfa)
3436                                         {
3437                                                 rtw_udelay_os(5);
3438                                         }
3439                                         else if (u4bRegOffset == 0xf9)
3440                                         {
3441                                                 rtw_udelay_os(1);
3442                                         }
3443                                         else if(u4bRegOffset == 0xffff)
3444                                         {
3445                                                 break;
3446                                         }
3447
3448                                         // Get 2nd hex value as register value.
3449                                         szLine += u4bMove;
3450                                         if(GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
3451                                         {
3452                                                 PHY_SetRFReg(Adapter, eRFPath, u4bRegOffset, bRFRegOffsetMask, u4bRegValue);
3453
3454                                                 // Temp add, for frequency lock, if no delay, that may cause
3455                                                 // frequency shift, ex: 2412MHz => 2417MHz
3456                                                 // If frequency shift, the following action may works.
3457                                                 // Fractional-N table in radio_a.txt
3458                                                 //0x2a 0x00001          // channel 1
3459                                                 //0x2b 0x00808          frequency divider.
3460                                                 //0x2b 0x53333
3461                                                 //0x2c 0x0000c
3462                                                 rtw_udelay_os(1);
3463                                         }
3464                                 }
3465                         }
3466                 }
3467         }
3468         else
3469         {
3470                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
3471         }
3472
3473         return rtStatus;
3474 }
3475
3476 VOID
3477 initDeltaSwingIndexTables(
3478         PADAPTER        Adapter,
3479         char*           Band,
3480         char*           Path,
3481         char*           Sign,
3482         char*           Channel,
3483         char*           Rate,
3484         char*           Data
3485 )
3486 {
3487         #define STR_EQUAL_5G(_band, _path, _sign, _rate, _chnl) \
3488                 ((strcmp(Band, _band) == 0) && (strcmp(Path, _path) == 0) && (strcmp(Sign, _sign) == 0) &&\
3489                 (strcmp(Rate, _rate) == 0) && (strcmp(Channel, _chnl) == 0)\
3490         )
3491         #define STR_EQUAL_2G(_band, _path, _sign, _rate) \
3492                 ((strcmp(Band, _band) == 0) && (strcmp(Path, _path) == 0) && (strcmp(Sign, _sign) == 0) &&\
3493                 (strcmp(Rate, _rate) == 0)\
3494         )
3495
3496         #define STORE_SWING_TABLE(_array, _iteratedIdx) \
3497                 for(token = strsep(&Data, delim); token != NULL; token = strsep(&Data, delim))\
3498                 {\
3499                         sscanf(token, "%d", &idx);\
3500                         _array[_iteratedIdx++] = (u8)idx;\
3501                 }\
3502
3503         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
3504         PDM_ODM_T               pDM_Odm = &pHalData->odmpriv;
3505         PODM_RF_CAL_T   pRFCalibrateInfo = &(pDM_Odm->RFCalibrateInfo);
3506         u32     j = 0;
3507         char    *token;
3508         char    delim[] = ",";
3509         u32     idx = 0;
3510
3511         //DBG_871X("===>initDeltaSwingIndexTables(): Band: %s;\nPath: %s;\nSign: %s;\nChannel: %s;\nRate: %s;\n, Data: %s;\n",
3512         //      Band, Path, Sign, Channel, Rate, Data);
3513
3514         if ( STR_EQUAL_2G("2G", "A", "+", "CCK") )
3515         {
3516                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_P, j);
3517         }
3518         else if ( STR_EQUAL_2G("2G", "A", "-", "CCK") )
3519         {
3520                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_N, j);
3521         }
3522         else if ( STR_EQUAL_2G("2G", "B", "+", "CCK") )
3523         {
3524                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_P, j);
3525         }
3526         else if ( STR_EQUAL_2G("2G", "B", "-", "CCK") )
3527         {
3528                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_N, j);
3529         }
3530         else if ( STR_EQUAL_2G("2G", "A", "+", "ALL") )
3531         {
3532                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GA_P, j);
3533         }
3534         else if ( STR_EQUAL_2G("2G", "A", "-", "ALL") )
3535         {
3536                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GA_N, j);
3537         }
3538         else if ( STR_EQUAL_2G("2G", "B", "+", "ALL") )
3539         {
3540                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GB_P, j);
3541         }
3542         else if ( STR_EQUAL_2G("2G", "B", "-", "ALL") )
3543         {
3544                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GB_N, j);
3545         }
3546         else if ( STR_EQUAL_5G("5G", "A", "+", "ALL", "0") )
3547         {
3548                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[0], j);
3549         }
3550         else if ( STR_EQUAL_5G("5G", "A", "-", "ALL", "0") )
3551         {
3552                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[0], j);
3553         }
3554         else if ( STR_EQUAL_5G("5G", "B", "+", "ALL", "0") )
3555         {
3556                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[0], j);
3557         }
3558         else if ( STR_EQUAL_5G("5G", "B", "-", "ALL", "0") )
3559         {
3560                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[0], j);
3561         }
3562         else if ( STR_EQUAL_5G("5G", "A", "+", "ALL", "1") )
3563         {
3564                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[1], j);
3565         }
3566         else if ( STR_EQUAL_5G("5G", "A", "-", "ALL", "1") )
3567         {
3568                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[1], j);
3569         }
3570         else if ( STR_EQUAL_5G("5G", "B", "+", "ALL", "1") )
3571         {
3572                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[1], j);
3573         }
3574         else if ( STR_EQUAL_5G("5G", "B", "-", "ALL", "1") )
3575         {
3576                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[1], j);
3577         }
3578         else if ( STR_EQUAL_5G("5G", "A", "+", "ALL", "2") )
3579         {
3580                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[2], j);
3581         }
3582         else if ( STR_EQUAL_5G("5G", "A", "-", "ALL", "2") )
3583         {
3584                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[2], j);
3585         }
3586         else if ( STR_EQUAL_5G("5G", "B", "+", "ALL", "2") )
3587         {
3588                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[2], j);
3589         }
3590         else if ( STR_EQUAL_5G("5G", "B", "-", "ALL", "2") )
3591         {
3592                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[2], j);
3593         }
3594         else if ( STR_EQUAL_5G("5G", "A", "+", "ALL", "3") )
3595         {
3596                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[3], j);
3597         }
3598         else if ( STR_EQUAL_5G("5G", "A", "-", "ALL", "3") )
3599         {
3600                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[3], j);
3601         }
3602         else if ( STR_EQUAL_5G("5G", "B", "+", "ALL", "3") )
3603         {
3604                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[3], j);
3605         }
3606         else if ( STR_EQUAL_5G("5G", "B", "-", "ALL", "3") )
3607         {
3608                 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[3], j);
3609         }
3610         else
3611         {
3612                 DBG_871X("===>initDeltaSwingIndexTables(): The input is invalid!!\n");
3613         }
3614 }
3615
3616 int
3617 PHY_ConfigRFWithTxPwrTrackParaFile(
3618         IN      PADAPTER                Adapter,
3619         IN      char*                   pFileName
3620 )
3621 {
3622         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
3623         PDM_ODM_T                       pDM_Odm = &pHalData->odmpriv;
3624         PODM_RF_CAL_T           pRFCalibrateInfo = &(pDM_Odm->RFCalibrateInfo);
3625         int     rlen = 0, rtStatus = _FAIL;
3626         char    *szLine, *ptmp;
3627         u32     i = 0, j = 0;
3628         char    c = 0;
3629
3630         if(!(Adapter->registrypriv.load_phy_file & LOAD_RF_TXPWR_TRACK_PARA_FILE))
3631                 return rtStatus;
3632
3633         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
3634
3635         if ((pHalData->rf_tx_pwr_track_len == 0) && (pHalData->rf_tx_pwr_track == NULL))
3636         {
3637                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
3638
3639                 if (rtw_is_file_readable(file_path) == _TRUE)
3640                 {
3641                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
3642                         if (rlen > 0)
3643                         {
3644                                 rtStatus = _SUCCESS;
3645                                 pHalData->rf_tx_pwr_track = rtw_zmalloc(rlen);
3646                                 if(pHalData->rf_tx_pwr_track) {
3647                                         _rtw_memcpy(pHalData->rf_tx_pwr_track, pHalData->para_file_buf, rlen);
3648                                         pHalData->rf_tx_pwr_track_len = rlen;
3649                                 }
3650                                 else {
3651                                         DBG_871X("%s rf_tx_pwr_track alloc fail !\n",__FUNCTION__);
3652                                 }
3653                         }
3654                 }
3655         }
3656         else
3657         {
3658                 if ((pHalData->rf_tx_pwr_track_len != 0) && (pHalData->rf_tx_pwr_track != NULL)) {
3659                         _rtw_memcpy(pHalData->para_file_buf, pHalData->rf_tx_pwr_track, pHalData->rf_tx_pwr_track_len);
3660                         rtStatus = _SUCCESS;
3661                 }
3662                 else {
3663                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
3664                 }
3665         }
3666
3667         if(rtStatus == _SUCCESS)
3668         {
3669                 //DBG_871X("%s(): read %s successfully\n", __FUNCTION__, pFileName);
3670
3671                 ptmp = pHalData->para_file_buf;
3672                 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
3673                 {
3674                         if ( ! IsCommentString(szLine) )
3675                         {
3676                                 char    band[5]="", path[5]="", sign[5]  = "";
3677                                 char    chnl[5]="", rate[10]="";
3678                                 char    data[300]=""; // 100 is too small
3679
3680                                 if (strlen(szLine) < 10 || szLine[0] != '[')
3681                                         continue;
3682
3683                                 strncpy(band, szLine+1, 2);
3684                                 strncpy(path, szLine+5, 1);
3685                                 strncpy(sign, szLine+8, 1);
3686
3687                                 i = 10; // szLine+10
3688                                 if ( ! ParseQualifiedString(szLine, &i, rate, '[', ']') ) {
3689                                         //DBG_871X("Fail to parse rate!\n");
3690                                 }
3691                                 if ( ! ParseQualifiedString(szLine, &i, chnl, '[', ']') ) {
3692                                         //DBG_871X("Fail to parse channel group!\n");
3693                                 }
3694                                 while ( szLine[i] != '{' && i < strlen(szLine))
3695                                         i++;
3696                                 if ( ! ParseQualifiedString(szLine, &i, data, '{', '}') ) {
3697                                         //DBG_871X("Fail to parse data!\n");
3698                                 }
3699
3700                                 initDeltaSwingIndexTables(Adapter, band, path, sign, chnl, rate, data);
3701                         }
3702                 }
3703         }
3704         else
3705         {
3706                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
3707         }
3708 #if 0
3709         for (i = 0; i < DELTA_SWINGIDX_SIZE; ++i)
3710         {
3711                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GA_P[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GA_P[i]);
3712                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GA_N[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GA_N[i]);
3713                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GB_P[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GB_P[i]);
3714                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GB_N[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GB_N[i]);
3715                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_P[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_P[i]);
3716                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_N[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_N[i]);
3717                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_P[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_P[i]);
3718                 DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_N[%d] = %d\n", i, pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_N[i]);
3719
3720                 for (j = 0; j < 3; ++j)
3721                 {
3722                     DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[%d][%d] = %d\n", j, i, pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[j][i]);
3723                     DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[%d][%d] = %d\n", j, i, pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[j][i]);
3724                     DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[%d][%d] = %d\n", j, i, pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[j][i]);
3725                     DBG_871X("pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[%d][%d] = %d\n", j, i, pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[j][i]);
3726                 }
3727         }
3728 #endif
3729         return rtStatus;
3730 }
3731
3732 int
3733 phy_ParsePowerLimitTableFile(
3734   PADAPTER              Adapter,
3735   char*                 buffer
3736 )
3737 {
3738         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
3739         u32     i = 0, forCnt = 0;
3740         u8      loadingStage = 0, limitValue = 0, fraction = 0;
3741         char    *szLine, *ptmp;
3742         int     rtStatus = _SUCCESS;
3743         char band[10], bandwidth[10], rateSection[10],
3744                 regulation[TXPWR_LMT_MAX_REGULATION_NUM][10], rfPath[10],colNumBuf[10];
3745         u8      colNum = 0;
3746
3747         DBG_871X("===>phy_ParsePowerLimitTableFile()\n" );
3748
3749         if ( Adapter->registrypriv.RegDecryptCustomFile == 1 )
3750                 phy_DecryptBBPgParaFile( Adapter, buffer);
3751
3752         ptmp = buffer;
3753         for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp))
3754         {
3755                 // skip comment
3756                 if ( IsCommentString( szLine ) ) {
3757                         continue;
3758                 }
3759
3760                 if( loadingStage == 0 ) {
3761                         for ( forCnt = 0; forCnt < TXPWR_LMT_MAX_REGULATION_NUM; ++forCnt )
3762                                 _rtw_memset( ( PVOID ) regulation[forCnt], 0, 10 );
3763                         _rtw_memset( ( PVOID ) band, 0, 10 );
3764                         _rtw_memset( ( PVOID ) bandwidth, 0, 10 );
3765                         _rtw_memset( ( PVOID ) rateSection, 0, 10 );
3766                         _rtw_memset( ( PVOID ) rfPath, 0, 10 );
3767                         _rtw_memset( ( PVOID ) colNumBuf, 0, 10 );
3768
3769                         if ( szLine[0] != '#' || szLine[1] != '#' )
3770                                 continue;
3771
3772                         // skip the space
3773                         i = 2;
3774                         while ( szLine[i] == ' ' || szLine[i] == '\t' )
3775                                 ++i;
3776
3777                         szLine[--i] = ' '; // return the space in front of the regulation info
3778
3779                         // Parse the label of the table
3780                         if ( ! ParseQualifiedString( szLine, &i, band, ' ', ',' ) ) {
3781                                 DBG_871X( "Fail to parse band!\n");
3782                                 return _FAIL;
3783                         }
3784                         if ( ! ParseQualifiedString( szLine, &i, bandwidth, ' ', ',' ) ) {
3785                                 DBG_871X("Fail to parse bandwidth!\n");
3786                                 return _FAIL;
3787                         }
3788                         if ( ! ParseQualifiedString( szLine, &i, rfPath, ' ', ',' ) ) {
3789                                 DBG_871X("Fail to parse rf path!\n");
3790                                 return _FAIL;
3791                         }
3792                         if ( ! ParseQualifiedString( szLine, &i, rateSection, ' ', ',' ) ) {
3793                                 DBG_871X("Fail to parse rate!\n");
3794                                 return _FAIL;
3795                         }
3796
3797                         loadingStage = 1;
3798                 }
3799                 else if ( loadingStage == 1 )
3800                 {
3801                         if ( szLine[0] != '#' || szLine[1] != '#' )
3802                                 continue;
3803
3804                         // skip the space
3805                         i = 2;
3806                         while ( szLine[i] == ' ' || szLine[i] == '\t' )
3807                                 ++i;
3808
3809                         if ( !eqNByte( (u8 *)(szLine + i), (u8 *)("START"), 5 ) ) {
3810                                 DBG_871X("Lost \"##   START\" label\n");
3811                                 return _FAIL;
3812                         }
3813
3814                         loadingStage = 2;
3815                 }
3816                 else if ( loadingStage == 2 )
3817                 {
3818                         if ( szLine[0] != '#' || szLine[1] != '#' )
3819                                 continue;
3820
3821                         // skip the space
3822                         i = 2;
3823                         while ( szLine[i] == ' ' || szLine[i] == '\t' )
3824                                 ++i;
3825
3826                         if ( ! ParseQualifiedString( szLine, &i, colNumBuf, '#', '#' ) ) {
3827                                 DBG_871X("Fail to parse column number!\n");
3828                                 return _FAIL;
3829                         }
3830
3831                         if ( !GetU1ByteIntegerFromStringInDecimal( colNumBuf, &colNum ) )
3832                                 return _FAIL;
3833
3834                         if ( colNum > TXPWR_LMT_MAX_REGULATION_NUM ) {
3835                                 DBG_871X("unvalid col number %d (greater than max %d)\n",
3836                                           colNum, TXPWR_LMT_MAX_REGULATION_NUM );
3837                                 return _FAIL;
3838                         }
3839
3840                         for ( forCnt = 0; forCnt < colNum; ++forCnt )
3841                         {
3842                                 u8      regulation_name_cnt = 0;
3843
3844                                 // skip the space
3845                                 while ( szLine[i] == ' ' || szLine[i] == '\t' )
3846                                         ++i;
3847
3848                                 while ( szLine[i] != ' ' && szLine[i] != '\t' && szLine[i] != '\0' )
3849                                         regulation[forCnt][regulation_name_cnt++] = szLine[i++];
3850                                 //DBG_871X("regulation %s!\n", regulation[forCnt]);
3851
3852                                 if ( regulation_name_cnt == 0 ) {
3853                                         DBG_871X("unvalid number of regulation!\n");
3854                                         return _FAIL;
3855                                 }
3856                         }
3857
3858                         loadingStage = 3;
3859                 }
3860                 else if ( loadingStage == 3 )
3861                 {
3862                         char    channel[10] = {0}, powerLimit[10] = {0};
3863                         u8      cnt = 0;
3864
3865                         // the table ends
3866                         if ( szLine[0] == '#' && szLine[1] == '#' ) {
3867                                 i = 2;
3868                                 while ( szLine[i] == ' ' || szLine[i] == '\t' )
3869                                         ++i;
3870
3871                                 if ( eqNByte( (u8 *)(szLine + i), (u8 *)("END"), 3 ) ) {
3872                                         loadingStage = 0;
3873                                         continue;
3874                                 }
3875                                 else {
3876                                         DBG_871X("Wrong format\n");
3877                                         DBG_871X("<===== phy_ParsePowerLimitTableFile()\n");
3878                                         return _FAIL;
3879                                 }
3880                         }
3881
3882                         if ( ( szLine[0] != 'c' && szLine[0] != 'C' ) ||
3883                                  ( szLine[1] != 'h' && szLine[1] != 'H' ) ) {
3884                                 DBG_871X("Meet wrong channel => power limt pair\n");
3885                                 continue;
3886                         }
3887                         i = 2;// move to the  location behind 'h'
3888
3889                         // load the channel number
3890                         cnt = 0;
3891                         while ( szLine[i] >= '0' && szLine[i] <= '9' ) {
3892                                 channel[cnt] = szLine[i];
3893                                 ++cnt;
3894                                 ++i;
3895                         }
3896                         //DBG_871X("chnl %s!\n", channel);
3897
3898                         for ( forCnt = 0; forCnt < colNum; ++forCnt )
3899                         {
3900                                 // skip the space between channel number and the power limit value
3901                                 while ( szLine[i] == ' ' || szLine[i] == '\t' )
3902                                         ++i;
3903
3904                                 // load the power limit value
3905                                 cnt = 0;
3906                                 fraction = 0;
3907                                 _rtw_memset( ( PVOID ) powerLimit, 0, 10 );
3908                                 while ( ( szLine[i] >= '0' && szLine[i] <= '9' ) || szLine[i] == '.' )
3909                                 {
3910                                         if ( szLine[i] == '.' ){
3911                                                 if ( ( szLine[i+1] >= '0' && szLine[i+1] <= '9' ) ) {
3912                                                         fraction = szLine[i+1];
3913                                                         i += 2;
3914                                                 }
3915                                                 else {
3916                                                         DBG_871X("Wrong fraction in TXPWR_LMT.txt\n");
3917                                                         return _FAIL;
3918                                                 }
3919
3920                                                 break;
3921                                         }
3922
3923                                         powerLimit[cnt] = szLine[i];
3924                                         ++cnt;
3925                                         ++i;
3926                                 }
3927
3928                                 if ( powerLimit[0] == '\0' ) {
3929                                         powerLimit[0] = '6';
3930                                         powerLimit[1] = '3';
3931                                         i += 2;
3932                                 }
3933                                 else {
3934                                         if ( !GetU1ByteIntegerFromStringInDecimal( powerLimit, &limitValue ) )
3935                                                 return _FAIL;
3936
3937                                         limitValue *= 2;
3938                                         cnt = 0;
3939                                         if ( fraction == '5' )
3940                                                 ++limitValue;
3941
3942                                         // the value is greater or equal to 100
3943                                         if ( limitValue >= 100 ) {
3944                                                 powerLimit[cnt++] = limitValue/100 + '0';
3945                                                 limitValue %= 100;
3946
3947                                                 if ( limitValue >= 10 ) {
3948                                                         powerLimit[cnt++] = limitValue/10 + '0';
3949                                                         limitValue %= 10;
3950                                                 }
3951                                                 else {
3952                                                         powerLimit[cnt++] = '0';
3953                                                 }
3954
3955                                                 powerLimit[cnt++] = limitValue + '0';
3956                                         }
3957                                         // the value is greater or equal to 10
3958                                         else if ( limitValue >= 10 ) {
3959                                                 powerLimit[cnt++] = limitValue/10 + '0';
3960                                                 limitValue %= 10;
3961                                                 powerLimit[cnt++] = limitValue + '0';
3962                                         }
3963                                         // the value is less than 10
3964                                         else
3965                                                 powerLimit[cnt++] = limitValue + '0';
3966
3967                                         powerLimit[cnt] = '\0';
3968                                 }
3969
3970                                 //DBG_871X("ch%s => %s\n", channel, powerLimit);
3971
3972                                 // store the power limit value
3973                                 PHY_SetTxPowerLimit( Adapter, (u8 *)regulation[forCnt], (u8 *)band,
3974                                         (u8 *)bandwidth, (u8 *)rateSection, (u8 *)rfPath, (u8 *)channel, (u8 *)powerLimit );
3975
3976                         }
3977                 }
3978                 else
3979                 {
3980                         DBG_871X("Abnormal loading stage in phy_ParsePowerLimitTableFile()!\n");
3981                         rtStatus = _FAIL;
3982                         break;
3983                 }
3984         }
3985
3986         DBG_871X("<===phy_ParsePowerLimitTableFile()\n");
3987         return rtStatus;
3988 }
3989
3990 int
3991 PHY_ConfigRFWithPowerLimitTableParaFile(
3992         IN      PADAPTER        Adapter,
3993         IN      char*           pFileName
3994 )
3995 {
3996         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
3997         int     rlen = 0, rtStatus = _FAIL;
3998
3999         if(!(Adapter->registrypriv.load_phy_file & LOAD_RF_TXPWR_LMT_PARA_FILE))
4000                 return rtStatus;
4001
4002         _rtw_memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
4003
4004         if ((pHalData->rf_tx_pwr_lmt_len == 0) && (pHalData->rf_tx_pwr_lmt == NULL))
4005         {
4006                 rtw_merge_string(file_path, PATH_LENGTH_MAX, rtw_phy_file_path, pFileName);
4007
4008                 if (rtw_is_file_readable(file_path) == _TRUE)
4009                 {
4010                         rlen = rtw_retrive_from_file(file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
4011                         if (rlen > 0)
4012                         {
4013                                 rtStatus = _SUCCESS;
4014                                 pHalData->rf_tx_pwr_lmt = rtw_zmalloc(rlen);
4015                                 if(pHalData->rf_tx_pwr_lmt) {
4016                                         _rtw_memcpy(pHalData->rf_tx_pwr_lmt, pHalData->para_file_buf, rlen);
4017                                         pHalData->rf_tx_pwr_lmt_len = rlen;
4018                                 }
4019                                 else {
4020                                         DBG_871X("%s rf_tx_pwr_lmt alloc fail !\n",__FUNCTION__);
4021                                 }
4022                         }
4023                 }
4024         }
4025         else
4026         {
4027                 if ((pHalData->rf_tx_pwr_lmt_len != 0) && (pHalData->rf_tx_pwr_lmt != NULL)) {
4028                         _rtw_memcpy(pHalData->para_file_buf, pHalData->rf_tx_pwr_lmt, pHalData->rf_tx_pwr_lmt_len);
4029                         rtStatus = _SUCCESS;
4030                 }
4031                 else {
4032                         DBG_871X("%s(): Critical Error !!!\n",__FUNCTION__);
4033                 }
4034         }
4035
4036         if(rtStatus == _SUCCESS)
4037         {
4038                 //DBG_871X("%s(): read %s ok\n", __FUNCTION__, pFileName);
4039                 rtStatus = phy_ParsePowerLimitTableFile( Adapter, pHalData->para_file_buf );
4040         }
4041         else
4042         {
4043                 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __FUNCTION__, pFileName);
4044         }
4045
4046         return rtStatus;
4047 }
4048 #endif
4049
4050