rtl8723bu/hal/phydm/halphyrf_ap.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
  21  #include "mp_precomp.h"
  22  #include "phydm_precomp.h"
  23
  24 #ifndef index_mapping_NUM_88E
  25  #define        index_mapping_NUM_88E   15
  26 #endif
  27
  28 //#if(DM_ODM_SUPPORT_TYPE & ODM_WIN)
  29
  30 #define         CALCULATE_SWINGTALBE_OFFSET(_offset, _direction, _size, _deltaThermal) \
  31                                         do {\
  32                                                 for(_offset = 0; _offset < _size; _offset++)\
  33                                                 {\
  34                                                         if(_deltaThermal < thermalThreshold[_direction][_offset])\
  35                                                         {\
  36                                                                 if(_offset != 0)\
  37                                                                         _offset--;\
  38                                                                 break;\
  39                                                         }\
  40                                                 }                       \
  41                                                 if(_offset >= _size)\
  42                                                         _offset = _size-1;\
  43                                         } while(0)
  44
  45
  46 void ConfigureTxpowerTrack(
  47         IN      PVOID           pDM_VOID,
  48         OUT     PTXPWRTRACK_CFG pConfig
  49         )
  50 {
  51         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
  52 #if RTL8812A_SUPPORT
  53 #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
  54         //if (IS_HARDWARE_TYPE_8812(pDM_Odm->Adapter))
  55         if(pDM_Odm->SupportICType==ODM_RTL8812)
  56                 ConfigureTxpowerTrack_8812A(pConfig);
  57         //else
  58 #endif
  59 #endif
  60
  61 #if RTL8814A_SUPPORT
  62         if(pDM_Odm->SupportICType== ODM_RTL8814A)
  63                 ConfigureTxpowerTrack_8814A(pConfig);
  64 #endif
  65
  66
  67 }
  68
  69 #if (RTL8192E_SUPPORT==1)
  70 VOID
  71 ODM_TXPowerTrackingCallback_ThermalMeter_92E(
  72 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
  73         IN      PVOID           pDM_VOID
  74 #else
  75         IN PADAPTER     Adapter
  76 #endif
  77         )
  78 {
  79         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
  80         u1Byte  ThermalValue = 0, delta, delta_IQK, delta_LCK, channel, is_decrease, rf_mimo_mode;
  81         u1Byte  ThermalValue_AVG_count = 0;
  82         u1Byte     OFDM_min_index = 10; //OFDM BB Swing should be less than +2.5dB, which is required by Arthur
  83         s1Byte  OFDM_index[2], index ;
  84         u4Byte  ThermalValue_AVG = 0, Reg0x18;
  85         u4Byte  i = 0, j = 0, rf;
  86         s4Byte  value32, CCK_index = 0, ele_A, ele_D, ele_C, X, Y;
  87         prtl8192cd_priv         priv = pDM_Odm->priv;
  88
  89         rf_mimo_mode = pDM_Odm->RFType;
  90         //ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("%s:%d rf_mimo_mode:%d\n", __FUNCTION__, __LINE__, rf_mimo_mode));
  91
  92 #ifdef MP_TEST
  93         if ((OPMODE & WIFI_MP_STATE) || priv->pshare->rf_ft_var.mp_specific) {
  94                 channel = priv->pshare->working_channel;
  95                 if (priv->pshare->mp_txpwr_tracking == FALSE)
  96                         return;
  97         } else
  98 #endif
  99         {
 100                 channel = (priv->pmib->dot11RFEntry.dot11channel);
 101         }
 102
 103         ThermalValue = (unsigned char)ODM_GetRFReg(pDM_Odm, RF_PATH_A, ODM_RF_T_METER_92E, 0xfc00);     //0x42: RF Reg[15:10] 88E
 104         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("\nReadback Thermal Meter = 0x%x pre thermal meter 0x%x EEPROMthermalmeter 0x%x\n", ThermalValue, priv->pshare->ThermalValue, priv->pmib->dot11RFEntry.ther));
 105
 106
 107         switch (rf_mimo_mode) {
 108                 case MIMO_1T1R:
 109                         rf = 1;
 110                         break;
 111                 case MIMO_2T2R:
 112                         rf = 2;
 113                         break;
 114                 default:
 115                         rf = 2;
 116                         break;
 117         }
 118
 119         //Query OFDM path A default setting     Bit[31:21]
 120         ele_D = PHY_QueryBBReg(priv, rOFDM0_XATxIQImbalance, bMaskOFDM_D);
 121         for (i = 0; i < OFDM_TABLE_SIZE_92E; i++) {
 122                 if (ele_D == (OFDMSwingTable_92E[i] >> 22)) {
 123                         OFDM_index[0] = (unsigned char)i;
 124                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("PathA 0xC80[31:22] = 0x%x, OFDM_index=%d\n", ele_D, OFDM_index[0]));
 125                         break;
 126                 }
 127         }
 128
 129         //Query OFDM path B default setting
 130         if (rf_mimo_mode == MIMO_2T2R) {
 131                 ele_D = PHY_QueryBBReg(priv, rOFDM0_XBTxIQImbalance, bMaskOFDM_D);
 132                 for (i = 0; i < OFDM_TABLE_SIZE_92E; i++) {
 133                         if (ele_D == (OFDMSwingTable_92E[i] >> 22)) {
 134                                 OFDM_index[1] = (unsigned char)i;
 135                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("PathB 0xC88[31:22] = 0x%x, OFDM_index=%d\n", ele_D, OFDM_index[1]));
 136                                 break;
 137                         }
 138                 }
 139         }
 140
 141         /* calculate average thermal meter */
 142         {
 143                 priv->pshare->ThermalValue_AVG_88XX[priv->pshare->ThermalValue_AVG_index_88XX] = ThermalValue;
 144                 priv->pshare->ThermalValue_AVG_index_88XX++;
 145                 if (priv->pshare->ThermalValue_AVG_index_88XX == AVG_THERMAL_NUM_88XX)
 146                         priv->pshare->ThermalValue_AVG_index_88XX = 0;
 147
 148                 for (i = 0; i < AVG_THERMAL_NUM_88XX; i++) {
 149                         if (priv->pshare->ThermalValue_AVG_88XX[i]) {
 150                                 ThermalValue_AVG += priv->pshare->ThermalValue_AVG_88XX[i];
 151                                 ThermalValue_AVG_count++;
 152                         }
 153                 }
 154
 155                 if (ThermalValue_AVG_count) {
 156                         ThermalValue = (unsigned char)(ThermalValue_AVG / ThermalValue_AVG_count);
 157                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("AVG Thermal Meter = 0x%x \n", ThermalValue));
 158                 }
 159         }
 160
 161         /* Initialize */
 162         if (!priv->pshare->ThermalValue) {
 163                 priv->pshare->ThermalValue = priv->pmib->dot11RFEntry.ther;
 164                 priv->pshare->ThermalValue_IQK = ThermalValue;
 165                 priv->pshare->ThermalValue_LCK = ThermalValue;
 166         }
 167
 168         if (ThermalValue != priv->pshare->ThermalValue) {
 169                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("\n******** START POWER TRACKING ********\n"));
 170                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("\nReadback Thermal Meter = 0x%x pre thermal meter 0x%x EEPROMthermalmeter 0x%x\n", ThermalValue, priv->pshare->ThermalValue, priv->pmib->dot11RFEntry.ther));
 171
 172                 delta = RTL_ABS(ThermalValue, priv->pmib->dot11RFEntry.ther);
 173                 delta_IQK = RTL_ABS(ThermalValue, priv->pshare->ThermalValue_IQK);
 174                 delta_LCK = RTL_ABS(ThermalValue, priv->pshare->ThermalValue_LCK);
 175                 is_decrease = ((ThermalValue < priv->pmib->dot11RFEntry.ther) ? 1 : 0);
 176
 177 #ifdef _TRACKING_TABLE_FILE
 178                 if (priv->pshare->rf_ft_var.pwr_track_file) {
 179                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("Diff: (%s)%d ==> get index from table : %d)\n", (is_decrease?"-":"+"), delta, get_tx_tracking_index(priv, channel, i, delta, is_decrease, 0)));
 180
 181                 if (is_decrease) {
 182                         for (i = 0; i < rf; i++) {
 183                                 OFDM_index[i] = priv->pshare->OFDM_index0[i] + get_tx_tracking_index(priv, channel, i, delta, is_decrease, 0);
 184                                 OFDM_index[i] = ((OFDM_index[i] > (OFDM_TABLE_SIZE_92E- 1)) ? (OFDM_TABLE_SIZE_92E - 1) : OFDM_index[i]);
 185                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,(">>> decrese power ---> new OFDM_INDEX:%d (%d + %d)\n", OFDM_index[i], priv->pshare->OFDM_index0[i], get_tx_tracking_index(priv, channel, i, delta, is_decrease, 0)));
 186                                 CCK_index = priv->pshare->CCK_index0 + get_tx_tracking_index(priv, channel, i, delta, is_decrease, 1);
 187                                 CCK_index = ((CCK_index > (CCK_TABLE_SIZE_92E - 1)) ? (CCK_TABLE_SIZE_92E - 1) : CCK_index);
 188                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,(">>> Decrese power ---> new CCK_INDEX:%d (%d + %d)\n",  CCK_index, priv->pshare->CCK_index0, get_tx_tracking_index(priv, channel, i, delta, is_decrease, 1)));
 189                         }
 190                 } else {
 191                         for (i = 0; i < rf; i++) {
 192                                 OFDM_index[i] = priv->pshare->OFDM_index0[i] - get_tx_tracking_index(priv, channel, i, delta, is_decrease, 0);
 193                                 OFDM_index[i] = ((OFDM_index[i] < OFDM_min_index) ?  OFDM_min_index : OFDM_index[i]);
 194                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,(">>> Increse power ---> new OFDM_INDEX:%d (%d - %d)\n", OFDM_index[i], priv->pshare->OFDM_index0[i], get_tx_tracking_index(priv, channel, i, delta, is_decrease, 0)));
 195                                 CCK_index = priv->pshare->CCK_index0 - get_tx_tracking_index(priv, channel, i, delta, is_decrease, 1);
 196                                 CCK_index = ((CCK_index < 0 )? 0 : CCK_index);
 197                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,(">>> Increse power ---> new CCK_INDEX:%d (%d - %d)\n", CCK_index, priv->pshare->CCK_index0, get_tx_tracking_index(priv, channel, i, delta, is_decrease, 1)));
 198                         }
 199                 }
 200                 }
 201 #endif //CFG_TRACKING_TABLE_FILE
 202
 203                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("OFDMSwingTable_92E[(unsigned int)OFDM_index[0]] = %x \n",OFDMSwingTable_92E[(unsigned int)OFDM_index[0]]));
 204                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("OFDMSwingTable_92E[(unsigned int)OFDM_index[1]] = %x \n",OFDMSwingTable_92E[(unsigned int)OFDM_index[1]]));
 205
 206                 //Adujst OFDM Ant_A according to IQK result
 207                 ele_D = (OFDMSwingTable_92E[(unsigned int)OFDM_index[0]] & 0xFFC00000) >> 22;
 208                 X = priv->pshare->RegE94;
 209                 Y = priv->pshare->RegE9C;
 210
 211                 if (X != 0) {
 212                         if ((X & 0x00000200) != 0)
 213                                 X = X | 0xFFFFFC00;
 214                         ele_A = ((X * ele_D) >> 8) & 0x000003FF;
 215
 216                         //new element C = element D x Y
 217                         if ((Y & 0x00000200) != 0)
 218                                 Y = Y | 0xFFFFFC00;
 219                         ele_C = ((Y * ele_D) >> 8) & 0x000003FF;
 220
 221                         //wirte new elements A, C, D to regC80 and regC94, element B is always 0
 222                         value32 = (ele_D << 22) | ((ele_C & 0x3F) << 16) | ele_A;
 223                         PHY_SetBBReg(priv, rOFDM0_XATxIQImbalance, bMaskDWord, value32);
 224
 225                         value32 = (ele_C&0x000003C0)>>6;
 226                         PHY_SetBBReg(priv, rOFDM0_XCTxAFE, bMaskH4Bits, value32);
 227
 228                         value32 = ((X * ele_D)>>7)&0x01;
 229                         PHY_SetBBReg(priv, rOFDM0_ECCAThreshold, BIT(24), value32);
 230                 } else {
 231                         PHY_SetBBReg(priv, rOFDM0_XATxIQImbalance, bMaskDWord, OFDMSwingTable_92E[(unsigned int)OFDM_index[0]]);
 232                         PHY_SetBBReg(priv, rOFDM0_XCTxAFE, bMaskH4Bits, 0x00);
 233                         PHY_SetBBReg(priv, rOFDM0_ECCAThreshold, BIT(24), 0x00);
 234                 }
 235
 236                 set_CCK_swing_index(priv, CCK_index);
 237
 238                 if (rf == 2) {
 239                         ele_D = (OFDMSwingTable_92E[(unsigned int)OFDM_index[1]] & 0xFFC00000) >> 22;
 240                         X = priv->pshare->RegEB4;
 241                         Y = priv->pshare->RegEBC;
 242
 243                         if (X != 0) {
 244                                 if ((X & 0x00000200) != 0)      //consider minus
 245                                         X = X | 0xFFFFFC00;
 246                                 ele_A = ((X * ele_D) >> 8) & 0x000003FF;
 247
 248                                 //new element C = element D x Y
 249                                 if ((Y & 0x00000200) != 0)
 250                                         Y = Y | 0xFFFFFC00;
 251                                 ele_C = ((Y * ele_D) >> 8) & 0x00003FF;
 252
 253                                 //wirte new elements A, C, D to regC88 and regC9C, element B is always 0
 254                                 value32 = (ele_D << 22) | ((ele_C & 0x3F) << 16) | ele_A;
 255                                 PHY_SetBBReg(priv, rOFDM0_XBTxIQImbalance, bMaskDWord, value32);
 256
 257                                 value32 = (ele_C & 0x000003C0) >> 6;
 258                                 PHY_SetBBReg(priv, rOFDM0_XDTxAFE, bMaskH4Bits, value32);
 259
 260                                 value32 = ((X * ele_D) >> 7) & 0x01;
 261                                 PHY_SetBBReg(priv, rOFDM0_ECCAThreshold, BIT(28), value32);
 262                         } else {
 263                                 PHY_SetBBReg(priv, rOFDM0_XBTxIQImbalance, bMaskDWord, OFDMSwingTable_92E[(unsigned int)OFDM_index[1]]);
 264                                 PHY_SetBBReg(priv, rOFDM0_XDTxAFE, bMaskH4Bits, 0x00);
 265                                 PHY_SetBBReg(priv, rOFDM0_ECCAThreshold, BIT(28), 0x00);
 266                         }
 267
 268                 }
 269
 270                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD, ("0xc80 = 0x%x \n", PHY_QueryBBReg(priv, rOFDM0_XATxIQImbalance, bMaskDWord)));
 271                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD, ("0xc88 = 0x%x \n", PHY_QueryBBReg(priv, rOFDM0_XBTxIQImbalance, bMaskDWord)));
 272
 273                 if (delta_IQK > 3) {
 274                         priv->pshare->ThermalValue_IQK = ThermalValue;
 275 #ifdef MP_TEST
 276                         if (!(priv->pshare->rf_ft_var.mp_specific && (OPMODE & (WIFI_MP_CTX_BACKGROUND | WIFI_MP_CTX_PACKET))))
 277 #endif
 278                                 PHY_IQCalibrate_8192E(pDM_Odm,false);
 279                 }
 280
 281                 if (delta_LCK > 8) {
 282                         RTL_W8(0x522, 0xff);
 283                         Reg0x18 = PHY_QueryRFReg(priv, RF_PATH_A, 0x18, bMask20Bits, 1);
 284                         PHY_SetRFReg(priv, RF_PATH_A, 0xB4, BIT(14), 1);
 285                         PHY_SetRFReg(priv, RF_PATH_A, 0x18, BIT(15), 1);
 286                         delay_ms(1);
 287                         PHY_SetRFReg(priv, RF_PATH_A, 0xB4, BIT(14), 0);
 288                         PHY_SetRFReg(priv, RF_PATH_A, 0x18, bMask20Bits, Reg0x18);
 289                         RTL_W8(0x522, 0x0);
 290                         priv->pshare->ThermalValue_LCK = ThermalValue;
 291                 }
 292         }
 293
 294         //update thermal meter value
 295         priv->pshare->ThermalValue = ThermalValue;
 296         for (i = 0 ; i < rf ; i++)
 297                 priv->pshare->OFDM_index[i] = OFDM_index[i];
 298         priv->pshare->CCK_index = CCK_index;
 299
 300         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,  ("\n******** END:%s() ********\n", __FUNCTION__));
 301 }
 302 #endif
 303
 304 #if (RTL8814A_SUPPORT ==1)
 305
 306 VOID
 307 ODM_TXPowerTrackingCallback_ThermalMeter_JaguarSeries2(
 308 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
 309         IN      PVOID           pDM_VOID
 310 #else
 311         IN PADAPTER     Adapter
 312 #endif
 313         )
 314 {
 315         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 316         u1Byte                  ThermalValue = 0, delta, delta_LCK, delta_IQK, channel, is_increase;
 317         u1Byte                  ThermalValue_AVG_count = 0, p = 0, i = 0;
 318         u4Byte                  ThermalValue_AVG = 0, Reg0x18;
 319         u4Byte                  BBSwingReg[4] = {rA_TxScale_Jaguar,rB_TxScale_Jaguar,rC_TxScale_Jaguar2,rD_TxScale_Jaguar2};
 320         s4Byte                  ele_D;
 321         u4Byte                  BBswingIdx;
 322         prtl8192cd_priv priv = pDM_Odm->priv;
 323         TXPWRTRACK_CFG  c;
 324         BOOLEAN                 bTSSIenable = FALSE;
 325         PODM_RF_CAL_T   pRFCalibrateInfo = &(pDM_Odm->RFCalibrateInfo);
 326
 327         //4 1. The following TWO tables decide the final index of OFDM/CCK swing table.
 328         pu1Byte                 deltaSwingTableIdx_TUP_A = NULL, deltaSwingTableIdx_TDOWN_A = NULL;
 329         pu1Byte                 deltaSwingTableIdx_TUP_B = NULL, deltaSwingTableIdx_TDOWN_B = NULL;
 330         //for 8814 add by Yu Chen
 331         pu1Byte                 deltaSwingTableIdx_TUP_C = NULL, deltaSwingTableIdx_TDOWN_C = NULL;
 332         pu1Byte                 deltaSwingTableIdx_TUP_D = NULL, deltaSwingTableIdx_TDOWN_D = NULL;
 333
 334 #ifdef MP_TEST
 335         if ((OPMODE & WIFI_MP_STATE) || priv->pshare->rf_ft_var.mp_specific) {
 336                 channel = priv->pshare->working_channel;
 337                 if (priv->pshare->mp_txpwr_tracking == FALSE)
 338                         return;
 339         } else
 340 #endif
 341         {
 342                 channel = (priv->pmib->dot11RFEntry.dot11channel);
 343         }
 344
 345         ConfigureTxpowerTrack(pDM_Odm, &c);
 346         pRFCalibrateInfo->DefaultOfdmIndex = priv->pshare->OFDM_index0[ODM_RF_PATH_A];
 347
 348         (*c.GetDeltaSwingTable)(pDM_Odm, (pu1Byte*)&deltaSwingTableIdx_TUP_A, (pu1Byte*)&deltaSwingTableIdx_TDOWN_A,
 349                                                                           (pu1Byte*)&deltaSwingTableIdx_TUP_B, (pu1Byte*)&deltaSwingTableIdx_TDOWN_B);
 350
 351         if(pDM_Odm->SupportICType & ODM_RTL8814A)       // for 8814 path C & D
 352         (*c.GetDeltaSwingTable8814only)(pDM_Odm, (pu1Byte*)&deltaSwingTableIdx_TUP_C, (pu1Byte*)&deltaSwingTableIdx_TDOWN_C,
 353                                                                           (pu1Byte*)&deltaSwingTableIdx_TUP_D, (pu1Byte*)&deltaSwingTableIdx_TDOWN_D);
 354
 355         ThermalValue = (u1Byte)ODM_GetRFReg(pDM_Odm, ODM_RF_PATH_A, c.ThermalRegAddr, 0xfc00); //0x42: RF Reg[15:10] 88E
 356         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 357                 ("\nReadback Thermal Meter = 0x%x, pre thermal meter 0x%x, EEPROMthermalmeter 0x%x\n", ThermalValue, pDM_Odm->RFCalibrateInfo.ThermalValue, priv->pmib->dot11RFEntry.ther));
 358
 359         /* Initialize */
 360         if (!pDM_Odm->RFCalibrateInfo.ThermalValue) {
 361                 pDM_Odm->RFCalibrateInfo.ThermalValue = priv->pmib->dot11RFEntry.ther;
 362         }
 363
 364         if (!pDM_Odm->RFCalibrateInfo.ThermalValue_LCK) {
 365                 pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = priv->pmib->dot11RFEntry.ther;
 366         }
 367
 368         if (!pDM_Odm->RFCalibrateInfo.ThermalValue_IQK) {
 369                 pDM_Odm->RFCalibrateInfo.ThermalValue_IQK = priv->pmib->dot11RFEntry.ther;
 370         }
 371
 372         bTSSIenable = (BOOLEAN)ODM_GetRFReg(pDM_Odm, ODM_RF_PATH_A, rRF_TxGainOffset, BIT7);    // check TSSI enable
 373
 374         //4 Query OFDM BB swing default setting         Bit[31:21]
 375         for(p = ODM_RF_PATH_A ; p < c.RfPathCount ; p++)
 376         {
 377                 ele_D = ODM_GetBBReg(pDM_Odm, BBSwingReg[p], 0xffe00000);
 378                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 379                         ("0x%x:0x%x ([31:21] = 0x%x)\n", BBSwingReg[p], ODM_GetBBReg(pDM_Odm, BBSwingReg[p], bMaskDWord), ele_D));
 380
 381                 for (BBswingIdx = 0; BBswingIdx < TXSCALE_TABLE_SIZE; BBswingIdx++) {//4
 382                         if (ele_D == TxScalingTable_Jaguar[BBswingIdx]) {
 383                                 pDM_Odm->RFCalibrateInfo.OFDM_index[p] = (u1Byte)BBswingIdx;
 384                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 385                                         ("OFDM_index[%d]=%d\n",p, pDM_Odm->RFCalibrateInfo.OFDM_index[p]));
 386                                 break;
 387                         }
 388                 }
 389                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD, ("KfreeOffset[%d]=%d\n",p, pRFCalibrateInfo->KfreeOffset[p]));
 390
 391         }
 392
 393         /* calculate average thermal meter */
 394         pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index] = ThermalValue;
 395         pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index++;
 396         if(pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index == c.AverageThermalNum)   //Average times =  c.AverageThermalNum
 397                 pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index = 0;
 398
 399         for(i = 0; i < c.AverageThermalNum; i++)
 400         {
 401                 if(pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[i])
 402                 {
 403                         ThermalValue_AVG += pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[i];
 404                         ThermalValue_AVG_count++;
 405                 }
 406         }
 407
 408         if(ThermalValue_AVG_count)               //Calculate Average ThermalValue after average enough times
 409         {
 410                 ThermalValue = (u1Byte)(ThermalValue_AVG / ThermalValue_AVG_count);
 411                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 412                         ("AVG Thermal Meter = 0x%X, EEPROMthermalmeter = 0x%X\n", ThermalValue, priv->pmib->dot11RFEntry.ther));
 413         }
 414
 415         //4 Calculate delta, delta_LCK, delta_IQK.
 416         delta = RTL_ABS(ThermalValue, priv->pmib->dot11RFEntry.ther);
 417         delta_LCK = RTL_ABS(ThermalValue, pDM_Odm->RFCalibrateInfo.ThermalValue_LCK);
 418         delta_IQK = RTL_ABS(ThermalValue, pDM_Odm->RFCalibrateInfo.ThermalValue_IQK);
 419         is_increase = ((ThermalValue < priv->pmib->dot11RFEntry.ther) ? 0 : 1);
 420
 421         //4 if necessary, do LCK.
 422         if (!(pDM_Odm->SupportICType & ODM_RTL8821)) {
 423                 if (delta_LCK > c.Threshold_IQK) {
 424                         ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD, ("delta_LCK(%d) >= Threshold_IQK(%d)\n", delta_LCK, c.Threshold_IQK));
 425                         pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = ThermalValue;
 426                         if (c.PHY_LCCalibrate)
 427                                 (*c.PHY_LCCalibrate)(pDM_Odm);
 428                 }
 429         }
 430
 431         if (delta_IQK > c.Threshold_IQK)
 432         {
 433                 panic_printk("%s(%d)\n", __FUNCTION__, __LINE__);
 434                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD, ("delta_IQK(%d) >= Threshold_IQK(%d)\n", delta_IQK, c.Threshold_IQK));
 435                 pDM_Odm->RFCalibrateInfo.ThermalValue_IQK = ThermalValue;
 436                 if(c.DoIQK)
 437                         (*c.DoIQK)(pDM_Odm, TRUE, 0, 0);
 438         }
 439
 440         if(!priv->pmib->dot11RFEntry.ther)      /*Don't do power tracking since no calibrated thermal value*/
 441                 return;
 442
 443          //4 Do Power Tracking
 444
 445          if(bTSSIenable == TRUE)
 446         {
 447                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("**********Enter PURE TSSI MODE**********\n"));
 448                 for (p = ODM_RF_PATH_A; p < c.RfPathCount; p++)
 449                         (*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, TSSI_MODE, p, 0);
 450         }
 451         else if (ThermalValue != pDM_Odm->RFCalibrateInfo.ThermalValue)
 452         {
 453                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 454                         ("\n******** START POWER TRACKING ********\n"));
 455                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 456                         ("\nReadback Thermal Meter = 0x%x pre thermal meter 0x%x EEPROMthermalmeter 0x%x\n", ThermalValue, pDM_Odm->RFCalibrateInfo.ThermalValue, priv->pmib->dot11RFEntry.ther));
 457
 458 #ifdef _TRACKING_TABLE_FILE
 459                 if (priv->pshare->rf_ft_var.pwr_track_file)
 460                 {
 461                         if (is_increase)                        // thermal is higher than base
 462                         {
 463                                 for (p = ODM_RF_PATH_A; p < c.RfPathCount; p++)
 464                                 {
 465                                         switch(p)
 466                                         {
 467                                         case ODM_RF_PATH_B:
 468                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 469                                                         ("deltaSwingTableIdx_TUP_B[%d] = %d\n", delta, deltaSwingTableIdx_TUP_B[delta]));
 470                                                 pRFCalibrateInfo->Absolute_OFDMSwingIdx[p] = deltaSwingTableIdx_TUP_B[delta];       // Record delta swing for mix mode power tracking
 471                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 472                                                         ("******Temp is higher and pDM_Odm->Absolute_OFDMSwingIdx[ODM_RF_PATH_B] = %d\n", pRFCalibrateInfo->Absolute_OFDMSwingIdx[p]));
 473                                         break;
 474
 475                                         default:
 476                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 477                                                         ("deltaSwingTableIdx_TUP_A[%d] = %d\n", delta, deltaSwingTableIdx_TUP_A[delta]));
 478                                                 pRFCalibrateInfo->Absolute_OFDMSwingIdx[p] = deltaSwingTableIdx_TUP_A[delta];        // Record delta swing for mix mode power tracking
 479                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 480                                                         ("******Temp is higher and pDM_Odm->Absolute_OFDMSwingIdx[ODM_RF_PATH_A] = %d\n", pRFCalibrateInfo->Absolute_OFDMSwingIdx[p]));
 481                                         break;
 482                                         }
 483                                 }
 484                         }
 485                         else                                    // thermal is lower than base
 486                         {
 487                                 for (p = ODM_RF_PATH_A; p < c.RfPathCount; p++)
 488                                 {
 489                                         switch(p)
 490                                         {
 491                                         case ODM_RF_PATH_B:
 492                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 493                                                         ("deltaSwingTableIdx_TDOWN_B[%d] = %d\n", delta, deltaSwingTableIdx_TDOWN_B[delta]));
 494                                                 pRFCalibrateInfo->Absolute_OFDMSwingIdx[p] = -1 * deltaSwingTableIdx_TDOWN_B[delta];        // Record delta swing for mix mode power tracking
 495                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 496                                                         ("******Temp is lower and pDM_Odm->Absolute_OFDMSwingIdx[ODM_RF_PATH_B] = %d\n", pRFCalibrateInfo->Absolute_OFDMSwingIdx[p]));
 497                                         break;
 498
 499                                         default:
 500                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 501                                                         ("deltaSwingTableIdx_TDOWN_A[%d] = %d\n", delta, deltaSwingTableIdx_TDOWN_A[delta]));
 502                                                 pRFCalibrateInfo->Absolute_OFDMSwingIdx[p] = -1 * deltaSwingTableIdx_TDOWN_A[delta];        // Record delta swing for mix mode power tracking
 503                                                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 504                                                         ("******Temp is lower and pDM_Odm->Absolute_OFDMSwingIdx[ODM_RF_PATH_A] = %d\n", pRFCalibrateInfo->Absolute_OFDMSwingIdx[p]));
 505                                         break;
 506                                         }
 507                                 }
 508                         }
 509
 510                         if (is_increase)
 511                         {
 512                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,(">>> increse power ---> \n"));
 513                                 for (p = ODM_RF_PATH_A; p < c.RfPathCount; p++)
 514                                 (*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, MIX_MODE, p, 0);
 515                         }
 516                         else
 517                         {
 518                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,(">>> decrese power --->\n"));
 519                                 for (p = ODM_RF_PATH_A; p < c.RfPathCount; p++)
 520                                 (*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, MIX_MODE, p, 0);
 521                         }
 522                 }
 523 #endif
 524
 525         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("\n******** END:%s() ********\n", __FUNCTION__));
 526         //update thermal meter value
 527         pDM_Odm->RFCalibrateInfo.ThermalValue =  ThermalValue;
 528
 529         }
 530 }
 531
 532 #endif
 533
 534
 535 VOID
 536 ODM_TXPowerTrackingCallback_ThermalMeter(
 537 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
 538         IN      PVOID           pDM_VOID
 539 #else
 540         IN PADAPTER     Adapter
 541 #endif
 542         )
 543 {
 544         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 545         PODM_RF_CAL_T   pRFCalibrateInfo = &(pDM_Odm->RFCalibrateInfo);
 546 #if (RTL8814A_SUPPORT == 1)             //use this function to do power tracking after 8814 by YuChen
 547         if (pDM_Odm->SupportICType & ODM_RTL8814A) {
 548                 ODM_TXPowerTrackingCallback_ThermalMeter_JaguarSeries2(pDM_Odm);
 549                 return;
 550                 }
 551 #endif
 552
 553 #if (RTL8192E_SUPPORT == 1)
 554         if (pDM_Odm->SupportICType==ODM_RTL8192E) {
 555                 ODM_TXPowerTrackingCallback_ThermalMeter_92E(pDM_Odm);
 556                 return;
 557         }
 558 #endif
 559
 560 #if !(DM_ODM_SUPPORT_TYPE & ODM_AP)
 561         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
 562         //PMGNT_INFO                    pMgntInfo = &Adapter->MgntInfo;
 563 #endif
 564
 565         u1Byte                  ThermalValue = 0, delta, delta_LCK, delta_IQK, offset;
 566         u1Byte                  ThermalValue_AVG_count = 0;
 567         u4Byte                  ThermalValue_AVG = 0;
 568 //      s4Byte                  ele_A=0, ele_D, TempCCk, X, value32;
 569 //      s4Byte                  Y, ele_C=0;
 570 //      s1Byte                  OFDM_index[2], CCK_index=0, OFDM_index_old[2]={0,0}, CCK_index_old=0, index;
 571 //      s1Byte                  deltaPowerIndex = 0;
 572         u4Byte                  i = 0;//, j = 0;
 573         BOOLEAN                 is2T = FALSE;
 574 //      BOOLEAN                 bInteralPA = FALSE;
 575
 576         u1Byte                  OFDM_max_index = 34, rf = (is2T) ? 2 : 1; //OFDM BB Swing should be less than +3.0dB, which is required by Arthur
 577         u1Byte                  Indexforchannel = 0;/*GetRightChnlPlaceforIQK(pHalData->CurrentChannel)*/
 578     enum            _POWER_DEC_INC { POWER_DEC, POWER_INC };
 579         #if (DM_ODM_SUPPORT_TYPE == ODM_CE)
 580         PDM_ODM_T               pDM_Odm = &pHalData->odmpriv;
 581         #endif
 582         #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
 583         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
 584         #endif
 585
 586         TXPWRTRACK_CFG  c;
 587
 588
 589         //4 1. The following TWO tables decide the final index of OFDM/CCK swing table.
 590         s1Byte                  deltaSwingTableIdx[2][index_mapping_NUM_88E] = {
 591                         // {{Power decreasing(lower temperature)}, {Power increasing(higher temperature)}}
 592                         {0,0,2,3,4,4,5,6,7,7,8,9,10,10,11}, {0,0,1,2,3,4,4,4,4,5,7,8,9,9,10}
 593                     };
 594         u1Byte                  thermalThreshold[2][index_mapping_NUM_88E]={
 595                         // {{Power decreasing(lower temperature)}, {Power increasing(higher temperature)}}
 596                                             {0,2,4,6,8,10,12,14,16,18,20,22,24,26,27}, {0,2,4,6,8,10,12,14,16,18,20,22,25,25,25}
 597                     };
 598
 599 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
 600         prtl8192cd_priv priv = pDM_Odm->priv;
 601 #endif
 602
 603         //4 2. Initilization ( 7 steps in total )
 604
 605         ConfigureTxpowerTrack(pDM_Odm, &c);
 606
 607         pDM_Odm->RFCalibrateInfo.TXPowerTrackingCallbackCnt++; //cosa add for debug
 608         pDM_Odm->RFCalibrateInfo.bTXPowerTrackingInit = TRUE;
 609
 610 #if (MP_DRIVER == 1)
 611     pDM_Odm->RFCalibrateInfo.TxPowerTrackControl = pHalData->TxPowerTrackControl; // <Kordan> We should keep updating the control variable according to HalData.
 612     // <Kordan> RFCalibrateInfo.RegA24 will be initialized when ODM HW configuring, but MP configures with para files.
 613     pDM_Odm->RFCalibrateInfo.RegA24 = 0x090e1317;
 614 #endif
 615
 616 #if (DM_ODM_SUPPORT_TYPE == ODM_AP) && defined(MP_TEST)
 617         if ((OPMODE & WIFI_MP_STATE) || pDM_Odm->priv->pshare->rf_ft_var.mp_specific) {
 618                 if(pDM_Odm->priv->pshare->mp_txpwr_tracking == FALSE)
 619                         return;
 620         }
 621 #endif
 622         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("===>odm_TXPowerTrackingCallback_ThermalMeter_8188E, pDM_Odm->BbSwingIdxCckBase: %d, pDM_Odm->BbSwingIdxOfdmBase: %d \n", pRFCalibrateInfo->BbSwingIdxCckBase, pRFCalibrateInfo->BbSwingIdxOfdmBase));
 623 /*
 624         if (!pDM_Odm->RFCalibrateInfo.TM_Trigger) {
 625                 ODM_SetRFReg(pDM_Odm, RF_PATH_A, c.ThermalRegAddr, BIT17 | BIT16, 0x3);
 626                 pDM_Odm->RFCalibrateInfo.TM_Trigger = 1;
 627                 return;
 628         }
 629 */
 630         ThermalValue = (u1Byte)ODM_GetRFReg(pDM_Odm, RF_PATH_A, c.ThermalRegAddr, 0xfc00);      //0x42: RF Reg[15:10] 88E
 631 #if !(DM_ODM_SUPPORT_TYPE & ODM_AP)
 632         if( ! ThermalValue || ! pDM_Odm->RFCalibrateInfo.TxPowerTrackControl)
 633 #else
 634         if( ! pDM_Odm->RFCalibrateInfo.TxPowerTrackControl)
 635 #endif
 636         return;
 637
 638         //4 3. Initialize ThermalValues of RFCalibrateInfo
 639
 640         if( ! pDM_Odm->RFCalibrateInfo.ThermalValue)
 641         {
 642                 pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = ThermalValue;
 643                 pDM_Odm->RFCalibrateInfo.ThermalValue_IQK = ThermalValue;
 644         }
 645
 646         if(pDM_Odm->RFCalibrateInfo.bReloadtxpowerindex)
 647         {
 648                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("reload ofdm index for band switch\n"));
 649         }
 650
 651         //4 4. Calculate average thermal meter
 652
 653         pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index] = ThermalValue;
 654         pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index++;
 655         if(pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index == c.AverageThermalNum)
 656                 pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index = 0;
 657
 658         for(i = 0; i < c.AverageThermalNum; i++)
 659         {
 660                 if(pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[i])
 661                 {
 662                         ThermalValue_AVG += pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[i];
 663                         ThermalValue_AVG_count++;
 664                 }
 665         }
 666
 667         if(ThermalValue_AVG_count)
 668         {
 669                 // Give the new thermo value a weighting
 670                 ThermalValue_AVG += (ThermalValue*4);
 671
 672                 ThermalValue = (u1Byte)(ThermalValue_AVG / (ThermalValue_AVG_count+4));
 673                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("AVG Thermal Meter = 0x%x \n", ThermalValue));
 674         }
 675
 676         //4 5. Calculate delta, delta_LCK, delta_IQK.
 677
 678         delta     = (ThermalValue > pDM_Odm->RFCalibrateInfo.ThermalValue)?(ThermalValue - pDM_Odm->RFCalibrateInfo.ThermalValue):(pDM_Odm->RFCalibrateInfo.ThermalValue - ThermalValue);
 679         delta_LCK = (ThermalValue > pDM_Odm->RFCalibrateInfo.ThermalValue_LCK)?(ThermalValue - pDM_Odm->RFCalibrateInfo.ThermalValue_LCK):(pDM_Odm->RFCalibrateInfo.ThermalValue_LCK - ThermalValue);
 680         delta_IQK = (ThermalValue > pDM_Odm->RFCalibrateInfo.ThermalValue_IQK)?(ThermalValue - pDM_Odm->RFCalibrateInfo.ThermalValue_IQK):(pDM_Odm->RFCalibrateInfo.ThermalValue_IQK - ThermalValue);
 681
 682         //4 6. If necessary, do LCK.
 683         if (!(pDM_Odm->SupportICType & ODM_RTL8821)) {
 684         /*if((delta_LCK > pHalData->Delta_LCK) && (pHalData->Delta_LCK != 0))*/
 685                 if (delta_LCK >= c.Threshold_IQK) {
 686                         /*Delta temperature is equal to or larger than 20 centigrade.*/
 687                         pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = ThermalValue;
 688                         (*c.PHY_LCCalibrate)(pDM_Odm);
 689                 }
 690         }
 691
 692         //3 7. If necessary, move the index of swing table to adjust Tx power.
 693
 694         if (delta > 0 && pDM_Odm->RFCalibrateInfo.TxPowerTrackControl)
 695         {
 696 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
 697             delta = ThermalValue > pHalData->EEPROMThermalMeter?(ThermalValue - pHalData->EEPROMThermalMeter):(pHalData->EEPROMThermalMeter - ThermalValue);
 698 #else
 699             delta = (ThermalValue > pDM_Odm->priv->pmib->dot11RFEntry.ther)?(ThermalValue - pDM_Odm->priv->pmib->dot11RFEntry.ther):(pDM_Odm->priv->pmib->dot11RFEntry.ther - ThermalValue);
 700 #endif
 701
 702
 703                 //4 7.1 The Final Power Index = BaseIndex + PowerIndexOffset
 704
 705 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
 706                 if(ThermalValue > pHalData->EEPROMThermalMeter) {
 707 #else
 708                 if(ThermalValue > pDM_Odm->priv->pmib->dot11RFEntry.ther) {
 709 #endif
 710                         CALCULATE_SWINGTALBE_OFFSET(offset, POWER_INC, index_mapping_NUM_88E, delta);
 711                         pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast = pDM_Odm->RFCalibrateInfo.DeltaPowerIndex;
 712                         pDM_Odm->RFCalibrateInfo.DeltaPowerIndex =  deltaSwingTableIdx[POWER_INC][offset];
 713
 714         } else {
 715
 716                         CALCULATE_SWINGTALBE_OFFSET(offset, POWER_DEC, index_mapping_NUM_88E, delta);
 717                         pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast = pDM_Odm->RFCalibrateInfo.DeltaPowerIndex;
 718                         pDM_Odm->RFCalibrateInfo.DeltaPowerIndex = (-1)*deltaSwingTableIdx[POWER_DEC][offset];
 719         }
 720
 721                 if (pDM_Odm->RFCalibrateInfo.DeltaPowerIndex == pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast)
 722                         pDM_Odm->RFCalibrateInfo.PowerIndexOffset = 0;
 723                 else
 724                         pDM_Odm->RFCalibrateInfo.PowerIndexOffset = pDM_Odm->RFCalibrateInfo.DeltaPowerIndex - pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast;
 725
 726             for(i = 0; i < rf; i++)
 727                 pDM_Odm->RFCalibrateInfo.OFDM_index[i] = pRFCalibrateInfo->BbSwingIdxOfdmBase + pDM_Odm->RFCalibrateInfo.PowerIndexOffset;
 728                 pDM_Odm->RFCalibrateInfo.CCK_index = pRFCalibrateInfo->BbSwingIdxCckBase + pDM_Odm->RFCalibrateInfo.PowerIndexOffset;
 729
 730                 pRFCalibrateInfo->BbSwingIdxCck = pDM_Odm->RFCalibrateInfo.CCK_index;
 731                 pRFCalibrateInfo->BbSwingIdxOfdm[RF_PATH_A] = pDM_Odm->RFCalibrateInfo.OFDM_index[RF_PATH_A];
 732
 733                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("The 'CCK' final index(%d) = BaseIndex(%d) + PowerIndexOffset(%d)\n", pRFCalibrateInfo->BbSwingIdxCck, pRFCalibrateInfo->BbSwingIdxCckBase, pDM_Odm->RFCalibrateInfo.PowerIndexOffset));
 734                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("The 'OFDM' final index(%d) = BaseIndex(%d) + PowerIndexOffset(%d)\n", pRFCalibrateInfo->BbSwingIdxOfdm[RF_PATH_A], pRFCalibrateInfo->BbSwingIdxOfdmBase, pDM_Odm->RFCalibrateInfo.PowerIndexOffset));
 735
 736                 //4 7.1 Handle boundary conditions of index.
 737
 738
 739                 for(i = 0; i < rf; i++)
 740                 {
 741                         if(pDM_Odm->RFCalibrateInfo.OFDM_index[i] > OFDM_max_index)
 742                         {
 743                                 pDM_Odm->RFCalibrateInfo.OFDM_index[i] = OFDM_max_index;
 744                         }
 745                         else if (pDM_Odm->RFCalibrateInfo.OFDM_index[i] < 0)
 746                         {
 747                                 pDM_Odm->RFCalibrateInfo.OFDM_index[i] = 0;
 748                         }
 749                 }
 750
 751                 if(pDM_Odm->RFCalibrateInfo.CCK_index > c.SwingTableSize_CCK-1)
 752                         pDM_Odm->RFCalibrateInfo.CCK_index = c.SwingTableSize_CCK-1;
 753                 else if (pDM_Odm->RFCalibrateInfo.CCK_index < 0)
 754                         pDM_Odm->RFCalibrateInfo.CCK_index = 0;
 755         }
 756         else
 757         {
 758                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 759                         ("The thermal meter is unchanged or TxPowerTracking OFF: ThermalValue: %d , pDM_Odm->RFCalibrateInfo.ThermalValue: %d)\n", ThermalValue, pDM_Odm->RFCalibrateInfo.ThermalValue));
 760                 pDM_Odm->RFCalibrateInfo.PowerIndexOffset = 0;
 761         }
 762         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 763                 ("TxPowerTracking: [CCK] Swing Current Index: %d, Swing Base Index: %d\n", pDM_Odm->RFCalibrateInfo.CCK_index, pRFCalibrateInfo->BbSwingIdxCckBase));
 764
 765         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 766                 ("TxPowerTracking: [OFDM] Swing Current Index: %d, Swing Base Index: %d\n", pDM_Odm->RFCalibrateInfo.OFDM_index[RF_PATH_A], pRFCalibrateInfo->BbSwingIdxOfdmBase));
 767
 768         if (pDM_Odm->RFCalibrateInfo.PowerIndexOffset != 0 && pDM_Odm->RFCalibrateInfo.TxPowerTrackControl)
 769         {
 770                 //4 7.2 Configure the Swing Table to adjust Tx Power.
 771
 772                         pDM_Odm->RFCalibrateInfo.bTxPowerChanged = TRUE; // Always TRUE after Tx Power is adjusted by power tracking.
 773                         //
 774                         // 2012/04/23 MH According to Luke's suggestion, we can not write BB digital
 775                         // to increase TX power. Otherwise, EVM will be bad.
 776                         //
 777                         // 2012/04/25 MH Add for tx power tracking to set tx power in tx agc for 88E.
 778                         if (ThermalValue > pDM_Odm->RFCalibrateInfo.ThermalValue)
 779                         {
 780                                 //ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 781                                 //      ("Temperature Increasing: delta_pi: %d , delta_t: %d, Now_t: %d, EFUSE_t: %d, Last_t: %d\n",
 782                                 //      pDM_Odm->RFCalibrateInfo.PowerIndexOffset, delta, ThermalValue, pHalData->EEPROMThermalMeter, pDM_Odm->RFCalibrateInfo.ThermalValue));
 783                         }
 784                         else if (ThermalValue < pDM_Odm->RFCalibrateInfo.ThermalValue)// Low temperature
 785                         {
 786                                 //ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,
 787                                 //      ("Temperature Decreasing: delta_pi: %d , delta_t: %d, Now_t: %d, EFUSE_t: %d, Last_t: %d\n",
 788                                 //              pDM_Odm->RFCalibrateInfo.PowerIndexOffset, delta, ThermalValue, pHalData->EEPROMThermalMeter, pDM_Odm->RFCalibrateInfo.ThermalValue));
 789                         }
 790 #if !(DM_ODM_SUPPORT_TYPE & ODM_AP)
 791                         if (ThermalValue > pHalData->EEPROMThermalMeter)
 792 #else
 793                         if (ThermalValue > pDM_Odm->priv->pmib->dot11RFEntry.ther)
 794 #endif
 795                         {
 796 //                              ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("Temperature(%d) hugher than PG value(%d), increases the power by TxAGC\n", ThermalValue, pHalData->EEPROMThermalMeter));
 797                                 (*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, TXAGC, 0, 0);
 798                         }
 799                         else
 800                         {
 801         //                      ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("Temperature(%d) lower than PG value(%d), increases the power by TxAGC\n", ThermalValue, pHalData->EEPROMThermalMeter));
 802                                 (*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, BBSWING, RF_PATH_A, Indexforchannel);
 803                                 if(is2T)
 804                                         (*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, BBSWING, RF_PATH_B, Indexforchannel);
 805                         }
 806
 807                         pRFCalibrateInfo->BbSwingIdxCckBase = pRFCalibrateInfo->BbSwingIdxCck;
 808                         pRFCalibrateInfo->BbSwingIdxOfdmBase = pRFCalibrateInfo->BbSwingIdxOfdm[RF_PATH_A];
 809                         pDM_Odm->RFCalibrateInfo.ThermalValue = ThermalValue;
 810
 811         }
 812
 813 #if !(DM_ODM_SUPPORT_TYPE & ODM_AP)
 814         // if((delta_IQK > pHalData->Delta_IQK) && (pHalData->Delta_IQK != 0))
 815         if ((delta_IQK >= 8)) // Delta temperature is equal to or larger than 20 centigrade.
 816                 (*c.DoIQK)(pDM_Odm, delta_IQK, ThermalValue, 8);
 817 #endif
 818
 819         ODM_RT_TRACE(pDM_Odm,ODM_COMP_TX_PWR_TRACK, ODM_DBG_LOUD,("<===dm_TXPowerTrackingCallback_ThermalMeter_8188E\n"));
 820
 821         pDM_Odm->RFCalibrateInfo.TXPowercount = 0;
 822 }
 823
 824 #if (DM_ODM_SUPPORT_TYPE & ODM_WIN)
 825
 826
 827 VOID
 828 phy_PathAStandBy(
 829         IN      PADAPTER        pAdapter
 830         )
 831 {
 832         RTPRINT(FINIT, INIT_IQK, ("Path-A standby mode!\n"));
 833
 834         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0x0);
 835         PHY_SetBBReg(pAdapter, 0x840, bMaskDWord, 0x00010000);
 836         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0x808000);
 837 }
 838
 839 //1 7.  IQK
 840 //#define MAX_TOLERANCE         5
 841 //#define IQK_DELAY_TIME                1               //ms
 842
 843 u1Byte                  //bit0 = 1 => Tx OK, bit1 = 1 => Rx OK
 844 phy_PathA_IQK_8192C(
 845         IN      PADAPTER        pAdapter,
 846         IN      BOOLEAN         configPathB
 847         )
 848 {
 849
 850         u4Byte regEAC, regE94, regE9C, regEA4;
 851         u1Byte result = 0x00;
 852         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 853
 854         RTPRINT(FINIT, INIT_IQK, ("Path A IQK!\n"));
 855
 856         //path-A IQK setting
 857         RTPRINT(FINIT, INIT_IQK, ("Path-A IQK setting!\n"));
 858         if(pAdapter->interfaceIndex == 0)
 859         {
 860                 PHY_SetBBReg(pAdapter, rTx_IQK_Tone_A, bMaskDWord, 0x10008c1f);
 861                 PHY_SetBBReg(pAdapter, rRx_IQK_Tone_A, bMaskDWord, 0x10008c1f);
 862         }
 863         else
 864         {
 865                 PHY_SetBBReg(pAdapter, rTx_IQK_Tone_A, bMaskDWord, 0x10008c22);
 866                 PHY_SetBBReg(pAdapter, rRx_IQK_Tone_A, bMaskDWord, 0x10008c22);
 867         }
 868
 869         PHY_SetBBReg(pAdapter, rTx_IQK_PI_A, bMaskDWord, 0x82140102);
 870
 871         PHY_SetBBReg(pAdapter, rRx_IQK_PI_A, bMaskDWord, configPathB ? 0x28160202 :
 872                 IS_81xxC_VENDOR_UMC_B_CUT(pHalData->VersionID)?0x28160202:0x28160502);
 873
 874         //path-B IQK setting
 875         if(configPathB)
 876         {
 877                 PHY_SetBBReg(pAdapter, rTx_IQK_Tone_B, bMaskDWord, 0x10008c22);
 878                 PHY_SetBBReg(pAdapter, rRx_IQK_Tone_B, bMaskDWord, 0x10008c22);
 879                 PHY_SetBBReg(pAdapter, rTx_IQK_PI_B, bMaskDWord, 0x82140102);
 880                 PHY_SetBBReg(pAdapter, rRx_IQK_PI_B, bMaskDWord, 0x28160202);
 881         }
 882
 883         //LO calibration setting
 884         RTPRINT(FINIT, INIT_IQK, ("LO calibration setting!\n"));
 885         PHY_SetBBReg(pAdapter, rIQK_AGC_Rsp, bMaskDWord, 0x001028d1);
 886
 887         //One shot, path A LOK & IQK
 888         RTPRINT(FINIT, INIT_IQK, ("One shot, path A LOK & IQK!\n"));
 889         PHY_SetBBReg(pAdapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
 890         PHY_SetBBReg(pAdapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
 891
 892         // delay x ms
 893         RTPRINT(FINIT, INIT_IQK, ("Delay %d ms for One shot, path A LOK & IQK.\n", IQK_DELAY_TIME));
 894         PlatformStallExecution(IQK_DELAY_TIME*1000);
 895
 896         // Check failed
 897         regEAC = PHY_QueryBBReg(pAdapter, rRx_Power_After_IQK_A_2, bMaskDWord);
 898         RTPRINT(FINIT, INIT_IQK, ("0xeac = 0x%x\n", regEAC));
 899         regE94 = PHY_QueryBBReg(pAdapter, rTx_Power_Before_IQK_A, bMaskDWord);
 900         RTPRINT(FINIT, INIT_IQK, ("0xe94 = 0x%x\n", regE94));
 901         regE9C= PHY_QueryBBReg(pAdapter, rTx_Power_After_IQK_A, bMaskDWord);
 902         RTPRINT(FINIT, INIT_IQK, ("0xe9c = 0x%x\n", regE9C));
 903         regEA4= PHY_QueryBBReg(pAdapter, rRx_Power_Before_IQK_A_2, bMaskDWord);
 904         RTPRINT(FINIT, INIT_IQK, ("0xea4 = 0x%x\n", regEA4));
 905
 906         if(!(regEAC & BIT28) &&
 907                 (((regE94 & 0x03FF0000)>>16) != 0x142) &&
 908                 (((regE9C & 0x03FF0000)>>16) != 0x42) )
 909                 result |= 0x01;
 910         else                                                    //if Tx not OK, ignore Rx
 911                 return result;
 912
 913         if(!(regEAC & BIT27) &&         //if Tx is OK, check whether Rx is OK
 914                 (((regEA4 & 0x03FF0000)>>16) != 0x132) &&
 915                 (((regEAC & 0x03FF0000)>>16) != 0x36))
 916                 result |= 0x02;
 917         else
 918                 RTPRINT(FINIT, INIT_IQK, ("Path A Rx IQK fail!!\n"));
 919
 920         return result;
 921
 922
 923 }
 924
 925 u1Byte                          //bit0 = 1 => Tx OK, bit1 = 1 => Rx OK
 926 phy_PathB_IQK_8192C(
 927         IN      PADAPTER        pAdapter
 928         )
 929 {
 930         u4Byte regEAC, regEB4, regEBC, regEC4, regECC;
 931         u1Byte  result = 0x00;
 932         RTPRINT(FINIT, INIT_IQK, ("Path B IQK!\n"));
 933
 934         //One shot, path B LOK & IQK
 935         RTPRINT(FINIT, INIT_IQK, ("One shot, path A LOK & IQK!\n"));
 936         PHY_SetBBReg(pAdapter, rIQK_AGC_Cont, bMaskDWord, 0x00000002);
 937         PHY_SetBBReg(pAdapter, rIQK_AGC_Cont, bMaskDWord, 0x00000000);
 938
 939         // delay x ms
 940         RTPRINT(FINIT, INIT_IQK, ("Delay %d ms for One shot, path B LOK & IQK.\n", IQK_DELAY_TIME));
 941         PlatformStallExecution(IQK_DELAY_TIME*1000);
 942
 943         // Check failed
 944         regEAC = PHY_QueryBBReg(pAdapter, rRx_Power_After_IQK_A_2, bMaskDWord);
 945         RTPRINT(FINIT, INIT_IQK, ("0xeac = 0x%x\n", regEAC));
 946         regEB4 = PHY_QueryBBReg(pAdapter, rTx_Power_Before_IQK_B, bMaskDWord);
 947         RTPRINT(FINIT, INIT_IQK, ("0xeb4 = 0x%x\n", regEB4));
 948         regEBC= PHY_QueryBBReg(pAdapter, rTx_Power_After_IQK_B, bMaskDWord);
 949         RTPRINT(FINIT, INIT_IQK, ("0xebc = 0x%x\n", regEBC));
 950         regEC4= PHY_QueryBBReg(pAdapter, rRx_Power_Before_IQK_B_2, bMaskDWord);
 951         RTPRINT(FINIT, INIT_IQK, ("0xec4 = 0x%x\n", regEC4));
 952         regECC= PHY_QueryBBReg(pAdapter, rRx_Power_After_IQK_B_2, bMaskDWord);
 953         RTPRINT(FINIT, INIT_IQK, ("0xecc = 0x%x\n", regECC));
 954
 955         if(!(regEAC & BIT31) &&
 956                 (((regEB4 & 0x03FF0000)>>16) != 0x142) &&
 957                 (((regEBC & 0x03FF0000)>>16) != 0x42))
 958                 result |= 0x01;
 959         else
 960                 return result;
 961
 962         if(!(regEAC & BIT30) &&
 963                 (((regEC4 & 0x03FF0000)>>16) != 0x132) &&
 964                 (((regECC & 0x03FF0000)>>16) != 0x36))
 965                 result |= 0x02;
 966         else
 967                 RTPRINT(FINIT, INIT_IQK, ("Path B Rx IQK fail!!\n"));
 968
 969
 970         return result;
 971
 972 }
 973
 974 VOID
 975 phy_PathAFillIQKMatrix(
 976         IN      PADAPTER        pAdapter,
 977         IN  BOOLEAN     bIQKOK,
 978         IN      s4Byte          result[][8],
 979         IN      u1Byte          final_candidate,
 980         IN  BOOLEAN             bTxOnly
 981         )
 982 {
 983         u4Byte  Oldval_0, X, TX0_A, reg;
 984         s4Byte  Y, TX0_C;
 985         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 986
 987         RTPRINT(FINIT, INIT_IQK, ("Path A IQ Calibration %s !\n",(bIQKOK)?"Success":"Failed"));
 988
 989         if(final_candidate == 0xFF)
 990                 return;
 991
 992         else if(bIQKOK)
 993         {
 994                 Oldval_0 = (PHY_QueryBBReg(pAdapter, rOFDM0_XATxIQImbalance, bMaskDWord) >> 22) & 0x3FF;
 995
 996                 X = result[final_candidate][0];
 997                 if ((X & 0x00000200) != 0)
 998                         X = X | 0xFFFFFC00;
 999                 TX0_A = (X * Oldval_0) >> 8;
1000                 RTPRINT(FINIT, INIT_IQK, ("X = 0x%x, TX0_A = 0x%x, Oldval_0 0x%x\n", X, TX0_A, Oldval_0));
1001                 PHY_SetBBReg(pAdapter, rOFDM0_XATxIQImbalance, 0x3FF, TX0_A);
1002                 PHY_SetBBReg(pAdapter, rOFDM0_ECCAThreshold, BIT(31), ((X * Oldval_0>>7) & 0x1));
1003
1004                 Y = result[final_candidate][1];
1005                 if ((Y & 0x00000200) != 0)
1006                         Y = Y | 0xFFFFFC00;
1007
1008                 //path B IQK result + 3
1009                 if(pAdapter->interfaceIndex == 1 && pHalData->CurrentBandType == BAND_ON_5G)
1010                         Y += 3;
1011
1012                 TX0_C = (Y * Oldval_0) >> 8;
1013                 RTPRINT(FINIT, INIT_IQK, ("Y = 0x%x, TX = 0x%x\n", Y, TX0_C));
1014                 PHY_SetBBReg(pAdapter, rOFDM0_XCTxAFE, 0xF0000000, ((TX0_C&0x3C0)>>6));
1015                 PHY_SetBBReg(pAdapter, rOFDM0_XATxIQImbalance, 0x003F0000, (TX0_C&0x3F));
1016                 PHY_SetBBReg(pAdapter, rOFDM0_ECCAThreshold, BIT(29), ((Y * Oldval_0>>7) & 0x1));
1017
1018                 if(bTxOnly)
1019                 {
1020                         RTPRINT(FINIT, INIT_IQK, ("phy_PathAFillIQKMatrix only Tx OK\n"));
1021                         return;
1022                 }
1023
1024                 reg = result[final_candidate][2];
1025                 PHY_SetBBReg(pAdapter, rOFDM0_XARxIQImbalance, 0x3FF, reg);
1026
1027                 reg = result[final_candidate][3] & 0x3F;
1028                 PHY_SetBBReg(pAdapter, rOFDM0_XARxIQImbalance, 0xFC00, reg);
1029
1030                 reg = (result[final_candidate][3] >> 6) & 0xF;
1031                 PHY_SetBBReg(pAdapter, rOFDM0_RxIQExtAnta, 0xF0000000, reg);
1032         }
1033 }
1034
1035 VOID
1036 phy_PathBFillIQKMatrix(
1037         IN      PADAPTER        pAdapter,
1038         IN  BOOLEAN     bIQKOK,
1039         IN      s4Byte          result[][8],
1040         IN      u1Byte          final_candidate,
1041         IN      BOOLEAN         bTxOnly                 //do Tx only
1042         )
1043 {
1044         u4Byte  Oldval_1, X, TX1_A, reg;
1045         s4Byte  Y, TX1_C;
1046         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1047
1048         RTPRINT(FINIT, INIT_IQK, ("Path B IQ Calibration %s !\n",(bIQKOK)?"Success":"Failed"));
1049
1050         if(final_candidate == 0xFF)
1051                 return;
1052
1053         else if(bIQKOK)
1054         {
1055                 Oldval_1 = (PHY_QueryBBReg(pAdapter, rOFDM0_XBTxIQImbalance, bMaskDWord) >> 22) & 0x3FF;
1056
1057                 X = result[final_candidate][4];
1058                 if ((X & 0x00000200) != 0)
1059                         X = X | 0xFFFFFC00;
1060                 TX1_A = (X * Oldval_1) >> 8;
1061                 RTPRINT(FINIT, INIT_IQK, ("X = 0x%x, TX1_A = 0x%x\n", X, TX1_A));
1062                 PHY_SetBBReg(pAdapter, rOFDM0_XBTxIQImbalance, 0x3FF, TX1_A);
1063                 PHY_SetBBReg(pAdapter, rOFDM0_ECCAThreshold, BIT(27), ((X * Oldval_1>>7) & 0x1));
1064
1065                 Y = result[final_candidate][5];
1066                 if ((Y & 0x00000200) != 0)
1067                         Y = Y | 0xFFFFFC00;
1068                 if(pHalData->CurrentBandType == BAND_ON_5G)
1069                         Y += 3;         //temp modify for preformance
1070                 TX1_C = (Y * Oldval_1) >> 8;
1071                 RTPRINT(FINIT, INIT_IQK, ("Y = 0x%x, TX1_C = 0x%x\n", Y, TX1_C));
1072                 PHY_SetBBReg(pAdapter, rOFDM0_XDTxAFE, 0xF0000000, ((TX1_C&0x3C0)>>6));
1073                 PHY_SetBBReg(pAdapter, rOFDM0_XBTxIQImbalance, 0x003F0000, (TX1_C&0x3F));
1074                 PHY_SetBBReg(pAdapter, rOFDM0_ECCAThreshold, BIT(25), ((Y * Oldval_1>>7) & 0x1));
1075
1076                 if(bTxOnly)
1077                         return;
1078
1079                 reg = result[final_candidate][6];
1080                 PHY_SetBBReg(pAdapter, rOFDM0_XBRxIQImbalance, 0x3FF, reg);
1081
1082                 reg = result[final_candidate][7] & 0x3F;
1083                 PHY_SetBBReg(pAdapter, rOFDM0_XBRxIQImbalance, 0xFC00, reg);
1084
1085                 reg = (result[final_candidate][7] >> 6) & 0xF;
1086                 PHY_SetBBReg(pAdapter, rOFDM0_AGCRSSITable, 0x0000F000, reg);
1087         }
1088 }
1089
1090
1091 BOOLEAN
1092 phy_SimularityCompare_92C(
1093         IN      PADAPTER        pAdapter,
1094         IN      s4Byte          result[][8],
1095         IN      u1Byte           c1,
1096         IN      u1Byte           c2
1097         )
1098 {
1099         u4Byte          i, j, diff, SimularityBitMap, bound = 0;
1100         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1101         u1Byte          final_candidate[2] = {0xFF, 0xFF};      //for path A and path B
1102         BOOLEAN         bResult = TRUE, is2T = IS_92C_SERIAL( pHalData->VersionID);
1103
1104         if(is2T)
1105                 bound = 8;
1106         else
1107                 bound = 4;
1108
1109         SimularityBitMap = 0;
1110
1111         for( i = 0; i < bound; i++ )
1112         {
1113                 diff = (result[c1][i] > result[c2][i]) ? (result[c1][i] - result[c2][i]) : (result[c2][i] - result[c1][i]);
1114                 if (diff > MAX_TOLERANCE)
1115                 {
1116                         if((i == 2 || i == 6) && !SimularityBitMap)
1117                         {
1118                                 if(result[c1][i]+result[c1][i+1] == 0)
1119                                         final_candidate[(i/4)] = c2;
1120                                 else if (result[c2][i]+result[c2][i+1] == 0)
1121                                         final_candidate[(i/4)] = c1;
1122                                 else
1123                                         SimularityBitMap = SimularityBitMap|(1<<i);
1124                         }
1125                         else
1126                                 SimularityBitMap = SimularityBitMap|(1<<i);
1127                 }
1128         }
1129
1130         if ( SimularityBitMap == 0)
1131         {
1132                 for( i = 0; i < (bound/4); i++ )
1133                 {
1134                         if(final_candidate[i] != 0xFF)
1135                         {
1136                                 for( j = i*4; j < (i+1)*4-2; j++)
1137                                         result[3][j] = result[final_candidate[i]][j];
1138                                 bResult = FALSE;
1139                         }
1140                 }
1141                 return bResult;
1142         }
1143         else if (!(SimularityBitMap & 0x0F))                    //path A OK
1144         {
1145                 for(i = 0; i < 4; i++)
1146                         result[3][i] = result[c1][i];
1147                 return FALSE;
1148         }
1149         else if (!(SimularityBitMap & 0xF0) && is2T)    //path B OK
1150         {
1151                 for(i = 4; i < 8; i++)
1152                         result[3][i] = result[c1][i];
1153                 return FALSE;
1154         }
1155         else
1156                 return FALSE;
1157
1158 }
1159
1160 /*
1161 return FALSE => do IQK again
1162 */
1163 BOOLEAN
1164 phy_SimularityCompare(
1165         IN      PADAPTER        pAdapter,
1166         IN      s4Byte          result[][8],
1167         IN      u1Byte           c1,
1168         IN      u1Byte           c2
1169         )
1170 {
1171         return phy_SimularityCompare_92C(pAdapter, result, c1, c2);
1172
1173 }
1174
1175 VOID
1176 phy_IQCalibrate_8192C(
1177         IN      PADAPTER        pAdapter,
1178         IN      s4Byte          result[][8],
1179         IN      u1Byte          t,
1180         IN      BOOLEAN         is2T
1181         )
1182 {
1183         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1184         u4Byte                  i;
1185         u1Byte                  PathAOK, PathBOK;
1186         u4Byte                  ADDA_REG[IQK_ADDA_REG_NUM] = {
1187                                                 rFPGA0_XCD_SwitchControl,       rBlue_Tooth,
1188                                                 rRx_Wait_CCA,           rTx_CCK_RFON,
1189                                                 rTx_CCK_BBON,   rTx_OFDM_RFON,
1190                                                 rTx_OFDM_BBON,  rTx_To_Rx,
1191                                                 rTx_To_Tx,              rRx_CCK,
1192                                                 rRx_OFDM,               rRx_Wait_RIFS,
1193                                                 rRx_TO_Rx,              rStandby,
1194                                                 rSleep,                         rPMPD_ANAEN };
1195         u4Byte                  IQK_MAC_REG[IQK_MAC_REG_NUM] = {
1196                                                 REG_TXPAUSE,            REG_BCN_CTRL,
1197                                                 REG_BCN_CTRL_1, REG_GPIO_MUXCFG};
1198
1199         //since 92C & 92D have the different define in IQK_BB_REG
1200         u4Byte  IQK_BB_REG_92C[IQK_BB_REG_NUM] = {
1201                                                         rOFDM0_TRxPathEnable,           rOFDM0_TRMuxPar,
1202                                                         rFPGA0_XCD_RFInterfaceSW,       rConfig_AntA,   rConfig_AntB,
1203                                                         rFPGA0_XAB_RFInterfaceSW,       rFPGA0_XA_RFInterfaceOE,
1204                                                         rFPGA0_XB_RFInterfaceOE,        /*rFPGA0_RFMOD*/ rCCK0_AFESetting
1205                                                         };
1206
1207         u4Byte  IQK_BB_REG_92D[IQK_BB_REG_NUM_92D] = {  //for normal
1208                                                         rFPGA0_XAB_RFInterfaceSW,       rFPGA0_XA_RFInterfaceOE,
1209                                                         rFPGA0_XB_RFInterfaceOE,        rOFDM0_TRMuxPar,
1210                                                         rFPGA0_XCD_RFInterfaceSW,       rOFDM0_TRxPathEnable,
1211                                                         /*rFPGA0_RFMOD*/ rCCK0_AFESetting,                      rFPGA0_AnalogParameter4,
1212                                                         rOFDM0_XAAGCCore1,              rOFDM0_XBAGCCore1
1213                                                 };
1214 #if MP_DRIVER
1215         const u4Byte    retryCount = 9;
1216 #else
1217         const u4Byte    retryCount = 2;
1218 #endif
1219         //Neil Chen--2011--05--19--
1220        //3 Path Div
1221         u1Byte                 rfPathSwitch=0x0;
1222
1223         // Note: IQ calibration must be performed after loading
1224         //              PHY_REG.txt , and radio_a, radio_b.txt
1225
1226         u4Byte bbvalue;
1227
1228         if(t==0)
1229         {
1230                  //bbvalue = PHY_QueryBBReg(pAdapter, rFPGA0_RFMOD, bMaskDWord);
1231                 //      RTPRINT(FINIT, INIT_IQK, ("phy_IQCalibrate_8192C()==>0x%08x\n",bbvalue));
1232
1233                         RTPRINT(FINIT, INIT_IQK, ("IQ Calibration for %s\n", (is2T ? "2T2R" : "1T1R")));
1234
1235                 // Save ADDA parameters, turn Path A ADDA on
1236                 phy_SaveADDARegisters(pAdapter, ADDA_REG, pHalData->ADDA_backup, IQK_ADDA_REG_NUM);
1237                 phy_SaveMACRegisters(pAdapter, IQK_MAC_REG, pHalData->IQK_MAC_backup);
1238                 phy_SaveADDARegisters(pAdapter, IQK_BB_REG_92C, pHalData->IQK_BB_backup, IQK_BB_REG_NUM);
1239         }
1240
1241         phy_PathADDAOn(pAdapter, ADDA_REG, TRUE, is2T);
1242
1243         if(t==0)
1244         {
1245                 pHalData->bRfPiEnable = (u1Byte)PHY_QueryBBReg(pAdapter, rFPGA0_XA_HSSIParameter1, BIT(8));
1246         }
1247
1248         if(!pHalData->bRfPiEnable){
1249                 // Switch BB to PI mode to do IQ Calibration.
1250                 phy_PIModeSwitch(pAdapter, TRUE);
1251         }
1252
1253         //MAC settings
1254         phy_MACSettingCalibration(pAdapter, IQK_MAC_REG, pHalData->IQK_MAC_backup);
1255
1256         //PHY_SetBBReg(pAdapter, rFPGA0_RFMOD, BIT24, 0x00);
1257         PHY_SetBBReg(pAdapter, rCCK0_AFESetting, bMaskDWord, (0x0f000000 | (PHY_QueryBBReg(pAdapter, rCCK0_AFESetting, bMaskDWord))) );
1258         PHY_SetBBReg(pAdapter, rOFDM0_TRxPathEnable, bMaskDWord, 0x03a05600);
1259         PHY_SetBBReg(pAdapter, rOFDM0_TRMuxPar, bMaskDWord, 0x000800e4);
1260         PHY_SetBBReg(pAdapter, rFPGA0_XCD_RFInterfaceSW, bMaskDWord, 0x22204000);
1261         {
1262                 PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT10, 0x01);
1263                 PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT26, 0x01);
1264                 PHY_SetBBReg(pAdapter, rFPGA0_XA_RFInterfaceOE, BIT10, 0x00);
1265                 PHY_SetBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT10, 0x00);
1266         }
1267
1268         if(is2T)
1269         {
1270                 PHY_SetBBReg(pAdapter, rFPGA0_XA_LSSIParameter, bMaskDWord, 0x00010000);
1271                 PHY_SetBBReg(pAdapter, rFPGA0_XB_LSSIParameter, bMaskDWord, 0x00010000);
1272         }
1273
1274         {
1275                 //Page B init
1276                 PHY_SetBBReg(pAdapter, rConfig_AntA, bMaskDWord, 0x00080000);
1277
1278                 if(is2T)
1279                 {
1280                         PHY_SetBBReg(pAdapter, rConfig_AntB, bMaskDWord, 0x00080000);
1281                 }
1282         }
1283         // IQ calibration setting
1284         RTPRINT(FINIT, INIT_IQK, ("IQK setting!\n"));
1285         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0x808000);
1286         PHY_SetBBReg(pAdapter, rTx_IQK, bMaskDWord, 0x01007c00);
1287         PHY_SetBBReg(pAdapter, rRx_IQK, bMaskDWord, 0x01004800);
1288
1289         for(i = 0 ; i < retryCount ; i++){
1290                 PathAOK = phy_PathA_IQK_8192C(pAdapter, is2T);
1291                 if(PathAOK == 0x03){
1292                         RTPRINT(FINIT, INIT_IQK, ("Path A IQK Success!!\n"));
1293                                 result[t][0] = (PHY_QueryBBReg(pAdapter, rTx_Power_Before_IQK_A, bMaskDWord)&0x3FF0000)>>16;
1294                                 result[t][1] = (PHY_QueryBBReg(pAdapter, rTx_Power_After_IQK_A, bMaskDWord)&0x3FF0000)>>16;
1295                                 result[t][2] = (PHY_QueryBBReg(pAdapter, rRx_Power_Before_IQK_A_2, bMaskDWord)&0x3FF0000)>>16;
1296                                 result[t][3] = (PHY_QueryBBReg(pAdapter, rRx_Power_After_IQK_A_2, bMaskDWord)&0x3FF0000)>>16;
1297                         break;
1298                 }
1299                 else if (i == (retryCount-1) && PathAOK == 0x01)        //Tx IQK OK
1300                 {
1301                         RTPRINT(FINIT, INIT_IQK, ("Path A IQK Only  Tx Success!!\n"));
1302
1303                         result[t][0] = (PHY_QueryBBReg(pAdapter, rTx_Power_Before_IQK_A, bMaskDWord)&0x3FF0000)>>16;
1304                         result[t][1] = (PHY_QueryBBReg(pAdapter, rTx_Power_After_IQK_A, bMaskDWord)&0x3FF0000)>>16;
1305                 }
1306         }
1307
1308         if(0x00 == PathAOK){
1309                 RTPRINT(FINIT, INIT_IQK, ("Path A IQK failed!!\n"));
1310         }
1311
1312         if(is2T){
1313                 phy_PathAStandBy(pAdapter);
1314
1315                 // Turn Path B ADDA on
1316                 phy_PathADDAOn(pAdapter, ADDA_REG, FALSE, is2T);
1317
1318                 for(i = 0 ; i < retryCount ; i++){
1319                         PathBOK = phy_PathB_IQK_8192C(pAdapter);
1320                         if(PathBOK == 0x03){
1321                                 RTPRINT(FINIT, INIT_IQK, ("Path B IQK Success!!\n"));
1322                                 result[t][4] = (PHY_QueryBBReg(pAdapter, rTx_Power_Before_IQK_B, bMaskDWord)&0x3FF0000)>>16;
1323                                 result[t][5] = (PHY_QueryBBReg(pAdapter, rTx_Power_After_IQK_B, bMaskDWord)&0x3FF0000)>>16;
1324                                 result[t][6] = (PHY_QueryBBReg(pAdapter, rRx_Power_Before_IQK_B_2, bMaskDWord)&0x3FF0000)>>16;
1325                                 result[t][7] = (PHY_QueryBBReg(pAdapter, rRx_Power_After_IQK_B_2, bMaskDWord)&0x3FF0000)>>16;
1326                                 break;
1327                         }
1328                         else if (i == (retryCount - 1) && PathBOK == 0x01)      //Tx IQK OK
1329                         {
1330                                 RTPRINT(FINIT, INIT_IQK, ("Path B Only Tx IQK Success!!\n"));
1331                                 result[t][4] = (PHY_QueryBBReg(pAdapter, rTx_Power_Before_IQK_B, bMaskDWord)&0x3FF0000)>>16;
1332                                 result[t][5] = (PHY_QueryBBReg(pAdapter, rTx_Power_After_IQK_B, bMaskDWord)&0x3FF0000)>>16;
1333                         }
1334                 }
1335
1336                 if(0x00 == PathBOK){
1337                         RTPRINT(FINIT, INIT_IQK, ("Path B IQK failed!!\n"));
1338                 }
1339         }
1340
1341         //Back to BB mode, load original value
1342         RTPRINT(FINIT, INIT_IQK, ("IQK:Back to BB mode, load original value!\n"));
1343         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0);
1344
1345         if(t!=0)
1346         {
1347                 if(!pHalData->bRfPiEnable){
1348                         // Switch back BB to SI mode after finish IQ Calibration.
1349                         phy_PIModeSwitch(pAdapter, FALSE);
1350                 }
1351
1352                 // Reload ADDA power saving parameters
1353                 phy_ReloadADDARegisters(pAdapter, ADDA_REG, pHalData->ADDA_backup, IQK_ADDA_REG_NUM);
1354
1355                 // Reload MAC parameters
1356                 phy_ReloadMACRegisters(pAdapter, IQK_MAC_REG, pHalData->IQK_MAC_backup);
1357
1358                 // Reload BB parameters
1359                 phy_ReloadADDARegisters(pAdapter, IQK_BB_REG_92C, pHalData->IQK_BB_backup, IQK_BB_REG_NUM);
1360
1361                 /*Restore RX initial gain*/
1362                 PHY_SetBBReg(pAdapter, rFPGA0_XA_LSSIParameter, bMaskDWord, 0x00032ed3);
1363                 if (is2T)
1364                         PHY_SetBBReg(pAdapter, rFPGA0_XB_LSSIParameter, bMaskDWord, 0x00032ed3);
1365                 //load 0xe30 IQC default value
1366                 PHY_SetBBReg(pAdapter, rTx_IQK_Tone_A, bMaskDWord, 0x01008c00);
1367                 PHY_SetBBReg(pAdapter, rRx_IQK_Tone_A, bMaskDWord, 0x01008c00);
1368
1369         }
1370         RTPRINT(FINIT, INIT_IQK, ("phy_IQCalibrate_8192C() <==\n"));
1371
1372 }
1373
1374
1375 VOID
1376 phy_LCCalibrate92C(
1377         IN      PADAPTER        pAdapter,
1378         IN      BOOLEAN         is2T
1379         )
1380 {
1381         u1Byte  tmpReg;
1382         u4Byte  RF_Amode=0, RF_Bmode=0, LC_Cal;
1383 //      HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1384
1385         //Check continuous TX and Packet TX
1386         tmpReg = PlatformEFIORead1Byte(pAdapter, 0xd03);
1387
1388         if((tmpReg&0x70) != 0)                  //Deal with contisuous TX case
1389                 PlatformEFIOWrite1Byte(pAdapter, 0xd03, tmpReg&0x8F);   //disable all continuous TX
1390         else                                                    // Deal with Packet TX case
1391                 PlatformEFIOWrite1Byte(pAdapter, REG_TXPAUSE, 0xFF);                    // block all queues
1392
1393         if((tmpReg&0x70) != 0)
1394         {
1395                 //1. Read original RF mode
1396                 //Path-A
1397                 RF_Amode = PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_AC, bMask12Bits);
1398
1399                 //Path-B
1400                 if(is2T)
1401                         RF_Bmode = PHY_QueryRFReg(pAdapter, RF_PATH_B, RF_AC, bMask12Bits);
1402
1403                 //2. Set RF mode = standby mode
1404                 //Path-A
1405                 PHY_SetRFReg(pAdapter, RF_PATH_A, RF_AC, bMask12Bits, (RF_Amode&0x8FFFF)|0x10000);
1406
1407                 //Path-B
1408                 if(is2T)
1409                         PHY_SetRFReg(pAdapter, RF_PATH_B, RF_AC, bMask12Bits, (RF_Bmode&0x8FFFF)|0x10000);
1410         }
1411
1412         //3. Read RF reg18
1413         LC_Cal = PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_CHNLBW, bMask12Bits);
1414
1415         //4. Set LC calibration begin   bit15
1416         PHY_SetRFReg(pAdapter, RF_PATH_A, RF_CHNLBW, bMask12Bits, LC_Cal|0x08000);
1417
1418         delay_ms(100);
1419
1420
1421         //Restore original situation
1422         if((tmpReg&0x70) != 0)  //Deal with contisuous TX case
1423         {
1424                 //Path-A
1425                 PlatformEFIOWrite1Byte(pAdapter, 0xd03, tmpReg);
1426                 PHY_SetRFReg(pAdapter, RF_PATH_A, RF_AC, bMask12Bits, RF_Amode);
1427
1428                 //Path-B
1429                 if(is2T)
1430                         PHY_SetRFReg(pAdapter, RF_PATH_B, RF_AC, bMask12Bits, RF_Bmode);
1431         }
1432         else // Deal with Packet TX case
1433         {
1434                 PlatformEFIOWrite1Byte(pAdapter, REG_TXPAUSE, 0x00);
1435         }
1436 }
1437
1438
1439 VOID
1440 phy_LCCalibrate(
1441         IN      PADAPTER        pAdapter,
1442         IN      BOOLEAN         is2T
1443         )
1444 {
1445         phy_LCCalibrate92C(pAdapter, is2T);
1446 }
1447
1448
1449
1450 //Analog Pre-distortion calibration
1451 #define         APK_BB_REG_NUM  8
1452 #define         APK_CURVE_REG_NUM 4
1453 #define         PATH_NUM                2
1454
1455 VOID
1456 phy_APCalibrate_8192C(
1457         IN      PADAPTER        pAdapter,
1458         IN      s1Byte          delta,
1459         IN      BOOLEAN         is2T
1460         )
1461 {
1462         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1463
1464         u4Byte                  regD[PATH_NUM];
1465         u4Byte                  tmpReg, index, offset, i, apkbound;
1466         u1Byte                  path, pathbound = PATH_NUM;
1467         u4Byte                  BB_backup[APK_BB_REG_NUM];
1468         u4Byte                  BB_REG[APK_BB_REG_NUM] = {
1469                                                 rFPGA1_TxBlock,         rOFDM0_TRxPathEnable,
1470                                                 rFPGA0_RFMOD,   rOFDM0_TRMuxPar,
1471                                                 rFPGA0_XCD_RFInterfaceSW,       rFPGA0_XAB_RFInterfaceSW,
1472                                                 rFPGA0_XA_RFInterfaceOE,        rFPGA0_XB_RFInterfaceOE };
1473         u4Byte                  BB_AP_MODE[APK_BB_REG_NUM] = {
1474                                                 0x00000020, 0x00a05430, 0x02040000,
1475                                                 0x000800e4, 0x00204000 };
1476         u4Byte                  BB_normal_AP_MODE[APK_BB_REG_NUM] = {
1477                                                 0x00000020, 0x00a05430, 0x02040000,
1478                                                 0x000800e4, 0x22204000 };
1479
1480         u4Byte                  AFE_backup[IQK_ADDA_REG_NUM];
1481         u4Byte                  AFE_REG[IQK_ADDA_REG_NUM] = {
1482                                                 rFPGA0_XCD_SwitchControl,       rBlue_Tooth,
1483                                                 rRx_Wait_CCA,           rTx_CCK_RFON,
1484                                                 rTx_CCK_BBON,   rTx_OFDM_RFON,
1485                                                 rTx_OFDM_BBON,  rTx_To_Rx,
1486                                                 rTx_To_Tx,              rRx_CCK,
1487                                                 rRx_OFDM,               rRx_Wait_RIFS,
1488                                                 rRx_TO_Rx,              rStandby,
1489                                                 rSleep,                         rPMPD_ANAEN };
1490
1491         u4Byte                  MAC_backup[IQK_MAC_REG_NUM];
1492         u4Byte                  MAC_REG[IQK_MAC_REG_NUM] = {
1493                                                 REG_TXPAUSE,            REG_BCN_CTRL,
1494                                                 REG_BCN_CTRL_1, REG_GPIO_MUXCFG};
1495
1496         u4Byte                  APK_RF_init_value[PATH_NUM][APK_BB_REG_NUM] = {
1497                                         {0x0852c, 0x1852c, 0x5852c, 0x1852c, 0x5852c},
1498                                         {0x2852e, 0x0852e, 0x3852e, 0x0852e, 0x0852e}
1499                                         };
1500
1501         u4Byte                  APK_normal_RF_init_value[PATH_NUM][APK_BB_REG_NUM] = {
1502                                         {0x0852c, 0x0a52c, 0x3a52c, 0x5a52c, 0x5a52c},  //path settings equal to path b settings
1503                                         {0x0852c, 0x0a52c, 0x5a52c, 0x5a52c, 0x5a52c}
1504                                         };
1505
1506         u4Byte                  APK_RF_value_0[PATH_NUM][APK_BB_REG_NUM] = {
1507                                         {0x52019, 0x52014, 0x52013, 0x5200f, 0x5208d},
1508                                         {0x5201a, 0x52019, 0x52016, 0x52033, 0x52050}
1509                                         };
1510
1511         u4Byte                  APK_normal_RF_value_0[PATH_NUM][APK_BB_REG_NUM] = {
1512                                         {0x52019, 0x52017, 0x52010, 0x5200d, 0x5206a},  //path settings equal to path b settings
1513                                         {0x52019, 0x52017, 0x52010, 0x5200d, 0x5206a}
1514                                         };
1515 #if 0
1516         u4Byte                  APK_RF_value_A[PATH_NUM][APK_BB_REG_NUM] = {
1517                                         {0x1adb0, 0x1adb0, 0x1ada0, 0x1ad90, 0x1ad80},
1518                                         {0x00fb0, 0x00fb0, 0x00fa0, 0x00f90, 0x00f80}
1519                                         };
1520 #endif
1521         u4Byte                  AFE_on_off[PATH_NUM] = {
1522                                         0x04db25a4, 0x0b1b25a4};        //path A on path B off / path A off path B on
1523
1524         u4Byte                  APK_offset[PATH_NUM] = {
1525                                         rConfig_AntA, rConfig_AntB};
1526
1527         u4Byte                  APK_normal_offset[PATH_NUM] = {
1528                                         rConfig_Pmpd_AntA, rConfig_Pmpd_AntB};
1529
1530         u4Byte                  APK_value[PATH_NUM] = {
1531                                         0x92fc0000, 0x12fc0000};
1532
1533         u4Byte                  APK_normal_value[PATH_NUM] = {
1534                                         0x92680000, 0x12680000};
1535
1536         s1Byte                  APK_delta_mapping[APK_BB_REG_NUM][13] = {
1537                                         {-4, -3, -2, -2, -1, -1, 0, 1, 2, 3, 4, 5, 6},
1538                                         {-4, -3, -2, -2, -1, -1, 0, 1, 2, 3, 4, 5, 6},
1539                                         {-6, -4, -2, -2, -1, -1, 0, 1, 2, 3, 4, 5, 6},
1540                                         {-1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6},
1541                                         {-11, -9, -7, -5, -3, -1, 0, 0, 0, 0, 0, 0, 0}
1542                                         };
1543
1544         u4Byte                  APK_normal_setting_value_1[13] = {
1545                                         0x01017018, 0xf7ed8f84, 0x1b1a1816, 0x2522201e, 0x322e2b28,
1546                                         0x433f3a36, 0x5b544e49, 0x7b726a62, 0xa69a8f84, 0xdfcfc0b3,
1547                                         0x12680000, 0x00880000, 0x00880000
1548                                         };
1549
1550         u4Byte                  APK_normal_setting_value_2[16] = {
1551                                         0x01c7021d, 0x01670183, 0x01000123, 0x00bf00e2, 0x008d00a3,
1552                                         0x0068007b, 0x004d0059, 0x003a0042, 0x002b0031, 0x001f0025,
1553                                         0x0017001b, 0x00110014, 0x000c000f, 0x0009000b, 0x00070008,
1554                                         0x00050006
1555                                         };
1556
1557         u4Byte                  APK_result[PATH_NUM][APK_BB_REG_NUM];   //val_1_1a, val_1_2a, val_2a, val_3a, val_4a
1558 //      u4Byte                  AP_curve[PATH_NUM][APK_CURVE_REG_NUM];
1559
1560         s4Byte                  BB_offset, delta_V, delta_offset;
1561
1562 #if MP_DRIVER == 1
1563         PMPT_CONTEXT    pMptCtx = &(pAdapter->MptCtx);
1564
1565         pMptCtx->APK_bound[0] = 45;
1566         pMptCtx->APK_bound[1] = 52;
1567 #endif
1568
1569         RTPRINT(FINIT, INIT_IQK, ("==>phy_APCalibrate_8192C() delta %d\n", delta));
1570         RTPRINT(FINIT, INIT_IQK, ("AP Calibration for %s\n", (is2T ? "2T2R" : "1T1R")));
1571         if(!is2T)
1572                 pathbound = 1;
1573
1574         //2 FOR NORMAL CHIP SETTINGS
1575
1576 // Temporarily do not allow normal driver to do the following settings because these offset
1577 // and value will cause RF internal PA to be unpredictably disabled by HW, such that RF Tx signal
1578 // will disappear after disable/enable card many times on 88CU. RF SD and DD have not find the
1579 // root cause, so we remove these actions temporarily. Added by tynli and SD3 Allen. 2010.05.31.
1580 #if MP_DRIVER != 1
1581         return;
1582 #endif
1583         //settings adjust for normal chip
1584         for(index = 0; index < PATH_NUM; index ++)
1585         {
1586                 APK_offset[index] = APK_normal_offset[index];
1587                 APK_value[index] = APK_normal_value[index];
1588                 AFE_on_off[index] = 0x6fdb25a4;
1589         }
1590
1591         for(index = 0; index < APK_BB_REG_NUM; index ++)
1592         {
1593                 for(path = 0; path < pathbound; path++)
1594                 {
1595                         APK_RF_init_value[path][index] = APK_normal_RF_init_value[path][index];
1596                         APK_RF_value_0[path][index] = APK_normal_RF_value_0[path][index];
1597                 }
1598                 BB_AP_MODE[index] = BB_normal_AP_MODE[index];
1599         }
1600
1601         apkbound = 6;
1602
1603         //save BB default value
1604         for(index = 0; index < APK_BB_REG_NUM ; index++)
1605         {
1606                 if(index == 0)          //skip
1607                         continue;
1608                 BB_backup[index] = PHY_QueryBBReg(pAdapter, BB_REG[index], bMaskDWord);
1609         }
1610
1611         //save MAC default value
1612         phy_SaveMACRegisters(pAdapter, MAC_REG, MAC_backup);
1613
1614         //save AFE default value
1615         phy_SaveADDARegisters(pAdapter, AFE_REG, AFE_backup, IQK_ADDA_REG_NUM);
1616
1617         for(path = 0; path < pathbound; path++)
1618         {
1619
1620
1621                 if(path == RF_PATH_A)
1622                 {
1623                         //path A APK
1624                         //load APK setting
1625                         //path-A
1626                         offset = rPdp_AntA;
1627                         for(index = 0; index < 11; index ++)
1628                         {
1629                                 PHY_SetBBReg(pAdapter, offset, bMaskDWord, APK_normal_setting_value_1[index]);
1630                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", offset, PHY_QueryBBReg(pAdapter, offset, bMaskDWord)));
1631
1632                                 offset += 0x04;
1633                         }
1634
1635                         PHY_SetBBReg(pAdapter, rConfig_Pmpd_AntB, bMaskDWord, 0x12680000);
1636
1637                         offset = rConfig_AntA;
1638                         for(; index < 13; index ++)
1639                         {
1640                                 PHY_SetBBReg(pAdapter, offset, bMaskDWord, APK_normal_setting_value_1[index]);
1641                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", offset, PHY_QueryBBReg(pAdapter, offset, bMaskDWord)));
1642
1643                                 offset += 0x04;
1644                         }
1645
1646                         //page-B1
1647                         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0x400000);
1648
1649                         //path A
1650                         offset = rPdp_AntA;
1651                         for(index = 0; index < 16; index++)
1652                         {
1653                                 PHY_SetBBReg(pAdapter, offset, bMaskDWord, APK_normal_setting_value_2[index]);
1654                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", offset, PHY_QueryBBReg(pAdapter, offset, bMaskDWord)));
1655
1656                                 offset += 0x04;
1657                         }
1658                         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0);
1659                 }
1660                 else if(path == RF_PATH_B)
1661                 {
1662                         //path B APK
1663                         //load APK setting
1664                         //path-B
1665                         offset = rPdp_AntB;
1666                         for(index = 0; index < 10; index ++)
1667                         {
1668                                 PHY_SetBBReg(pAdapter, offset, bMaskDWord, APK_normal_setting_value_1[index]);
1669                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", offset, PHY_QueryBBReg(pAdapter, offset, bMaskDWord)));
1670
1671                                 offset += 0x04;
1672                         }
1673                         PHY_SetBBReg(pAdapter, rConfig_Pmpd_AntA, bMaskDWord, 0x12680000);
1674
1675                         PHY_SetBBReg(pAdapter, rConfig_Pmpd_AntB, bMaskDWord, 0x12680000);
1676
1677                         offset = rConfig_AntA;
1678                         index = 11;
1679                         for(; index < 13; index ++) //offset 0xb68, 0xb6c
1680                         {
1681                                 PHY_SetBBReg(pAdapter, offset, bMaskDWord, APK_normal_setting_value_1[index]);
1682                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", offset, PHY_QueryBBReg(pAdapter, offset, bMaskDWord)));
1683
1684                                 offset += 0x04;
1685                         }
1686
1687                         //page-B1
1688                         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0x400000);
1689
1690                         //path B
1691                         offset = 0xb60;
1692                         for(index = 0; index < 16; index++)
1693                         {
1694                                 PHY_SetBBReg(pAdapter, offset, bMaskDWord, APK_normal_setting_value_2[index]);
1695                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", offset, PHY_QueryBBReg(pAdapter, offset, bMaskDWord)));
1696
1697                                 offset += 0x04;
1698                         }
1699                         PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0);
1700                 }
1701
1702                 //save RF default value
1703                 regD[path] = PHY_QueryRFReg(pAdapter, path, RF_TXBIAS_A, bRFRegOffsetMask);
1704
1705                 //Path A AFE all on, path B AFE All off or vise versa
1706                 for(index = 0; index < IQK_ADDA_REG_NUM ; index++)
1707                         PHY_SetBBReg(pAdapter, AFE_REG[index], bMaskDWord, AFE_on_off[path]);
1708                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0xe70 %x\n", PHY_QueryBBReg(pAdapter, rRx_Wait_CCA, bMaskDWord)));
1709
1710                 //BB to AP mode
1711                 if(path == 0)
1712                 {
1713                         for(index = 0; index < APK_BB_REG_NUM ; index++)
1714                         {
1715
1716                                 if(index == 0)          //skip
1717                                         continue;
1718                                 else if (index < 5)
1719                                 PHY_SetBBReg(pAdapter, BB_REG[index], bMaskDWord, BB_AP_MODE[index]);
1720                                 else if (BB_REG[index] == 0x870)
1721                                         PHY_SetBBReg(pAdapter, BB_REG[index], bMaskDWord, BB_backup[index]|BIT10|BIT26);
1722                                 else
1723                                         PHY_SetBBReg(pAdapter, BB_REG[index], BIT10, 0x0);
1724                         }
1725
1726                         PHY_SetBBReg(pAdapter, rTx_IQK_Tone_A, bMaskDWord, 0x01008c00);
1727                         PHY_SetBBReg(pAdapter, rRx_IQK_Tone_A, bMaskDWord, 0x01008c00);
1728                 }
1729                 else            //path B
1730                 {
1731                         PHY_SetBBReg(pAdapter, rTx_IQK_Tone_B, bMaskDWord, 0x01008c00);
1732                         PHY_SetBBReg(pAdapter, rRx_IQK_Tone_B, bMaskDWord, 0x01008c00);
1733
1734                 }
1735
1736                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x800 %x\n", PHY_QueryBBReg(pAdapter, 0x800, bMaskDWord)));
1737
1738                 //MAC settings
1739                 phy_MACSettingCalibration(pAdapter, MAC_REG, MAC_backup);
1740
1741                 if(path == RF_PATH_A)   //Path B to standby mode
1742                 {
1743                         PHY_SetRFReg(pAdapter, RF_PATH_B, RF_AC, bRFRegOffsetMask, 0x10000);
1744                 }
1745                 else                    //Path A to standby mode
1746                 {
1747                         PHY_SetRFReg(pAdapter, RF_PATH_A, RF_AC, bRFRegOffsetMask, 0x10000);
1748                         PHY_SetRFReg(pAdapter, RF_PATH_A, RF_MODE1, bRFRegOffsetMask, 0x1000f);
1749                         PHY_SetRFReg(pAdapter, RF_PATH_A, RF_MODE2, bRFRegOffsetMask, 0x20103);
1750                 }
1751
1752                 delta_offset = ((delta+14)/2);
1753                 if(delta_offset < 0)
1754                         delta_offset = 0;
1755                 else if (delta_offset > 12)
1756                         delta_offset = 12;
1757
1758                 //AP calibration
1759                 for(index = 0; index < APK_BB_REG_NUM; index++)
1760                 {
1761                         if(index != 1)  //only DO PA11+PAD01001, AP RF setting
1762                                 continue;
1763
1764                         tmpReg = APK_RF_init_value[path][index];
1765 #if 1
1766                         if(!pHalData->bAPKThermalMeterIgnore)
1767                         {
1768                                 BB_offset = (tmpReg & 0xF0000) >> 16;
1769
1770                                 if(!(tmpReg & BIT15)) //sign bit 0
1771                                 {
1772                                         BB_offset = -BB_offset;
1773                                 }
1774
1775                                 delta_V = APK_delta_mapping[index][delta_offset];
1776
1777                                 BB_offset += delta_V;
1778
1779                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() APK index %d tmpReg 0x%x delta_V %d delta_offset %d\n", index, tmpReg, delta_V, delta_offset));
1780
1781                                 if(BB_offset < 0)
1782                                 {
1783                                         tmpReg = tmpReg & (~BIT15);
1784                                         BB_offset = -BB_offset;
1785                                 }
1786                                 else
1787                                 {
1788                                         tmpReg = tmpReg | BIT15;
1789                                 }
1790                                 tmpReg = (tmpReg & 0xFFF0FFFF) | (BB_offset << 16);
1791                         }
1792 #endif
1793
1794 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1795                         if(IS_81xxC_VENDOR_UMC_B_CUT(pHalData->VersionID))
1796                                 PHY_SetRFReg(pAdapter, path, RF_IPA_A, bRFRegOffsetMask, 0x894ae);
1797                         else
1798 #endif
1799                                 PHY_SetRFReg(pAdapter, path, RF_IPA_A, bRFRegOffsetMask, 0x8992e);
1800                         RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0xc %x\n", PHY_QueryRFReg(pAdapter, path, RF_IPA_A, bRFRegOffsetMask)));
1801                         PHY_SetRFReg(pAdapter, path, RF_AC, bRFRegOffsetMask, APK_RF_value_0[path][index]);
1802                         RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x0 %x\n", PHY_QueryRFReg(pAdapter, path, RF_AC, bRFRegOffsetMask)));
1803                         PHY_SetRFReg(pAdapter, path, RF_TXBIAS_A, bRFRegOffsetMask, tmpReg);
1804                         RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0xd %x\n", PHY_QueryRFReg(pAdapter, path, RF_TXBIAS_A, bRFRegOffsetMask)));
1805
1806                         // PA11+PAD01111, one shot
1807                         i = 0;
1808                         do
1809                         {
1810                                 PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0x800000);
1811                                 {
1812                                         PHY_SetBBReg(pAdapter, APK_offset[path], bMaskDWord, APK_value[0]);
1813                                         RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", APK_offset[path], PHY_QueryBBReg(pAdapter, APK_offset[path], bMaskDWord)));
1814                                         delay_ms(3);
1815                                         PHY_SetBBReg(pAdapter, APK_offset[path], bMaskDWord, APK_value[1]);
1816                                         RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0x%x value 0x%x\n", APK_offset[path], PHY_QueryBBReg(pAdapter, APK_offset[path], bMaskDWord)));
1817
1818                                         delay_ms(20);
1819                                 }
1820                                 PHY_SetBBReg(pAdapter, rFPGA0_IQK, 0xffffff00, 0);
1821
1822                                 if(path == RF_PATH_A)
1823                                         tmpReg = PHY_QueryBBReg(pAdapter, rAPK, 0x03E00000);
1824                                 else
1825                                         tmpReg = PHY_QueryBBReg(pAdapter, rAPK, 0xF8000000);
1826                                 RTPRINT(FINIT, INIT_IQK, ("phy_APCalibrate_8192C() offset 0xbd8[25:21] %x\n", tmpReg));
1827
1828
1829                                 i++;
1830                         }
1831                         while(tmpReg > apkbound && i < 4);
1832
1833                         APK_result[path][index] = tmpReg;
1834                 }
1835         }
1836
1837         //reload MAC default value
1838         phy_ReloadMACRegisters(pAdapter, MAC_REG, MAC_backup);
1839
1840         //reload BB default value
1841         for(index = 0; index < APK_BB_REG_NUM ; index++)
1842         {
1843
1844                 if(index == 0)          //skip
1845                         continue;
1846                 PHY_SetBBReg(pAdapter, BB_REG[index], bMaskDWord, BB_backup[index]);
1847         }
1848
1849         //reload AFE default value
1850         phy_ReloadADDARegisters(pAdapter, AFE_REG, AFE_backup, IQK_ADDA_REG_NUM);
1851
1852         //reload RF path default value
1853         for(path = 0; path < pathbound; path++)
1854         {
1855                 PHY_SetRFReg(pAdapter, path, RF_TXBIAS_A, bRFRegOffsetMask, regD[path]);
1856                 if(path == RF_PATH_B)
1857                 {
1858                         PHY_SetRFReg(pAdapter, RF_PATH_A, RF_MODE1, bRFRegOffsetMask, 0x1000f);
1859                         PHY_SetRFReg(pAdapter, RF_PATH_A, RF_MODE2, bRFRegOffsetMask, 0x20101);
1860                 }
1861
1862                 //note no index == 0
1863                 if (APK_result[path][1] > 6)
1864                         APK_result[path][1] = 6;
1865                 RTPRINT(FINIT, INIT_IQK, ("apk path %d result %d 0x%x \t", path, 1, APK_result[path][1]));
1866         }
1867
1868         RTPRINT(FINIT, INIT_IQK, ("\n"));
1869
1870
1871         for(path = 0; path < pathbound; path++)
1872         {
1873                 PHY_SetRFReg(pAdapter, path, RF_BS_PA_APSET_G1_G4, bRFRegOffsetMask,
1874                 ((APK_result[path][1] << 15) | (APK_result[path][1] << 10) | (APK_result[path][1] << 5) | APK_result[path][1]));
1875                 if(path == RF_PATH_A)
1876                         PHY_SetRFReg(pAdapter, path, RF_BS_PA_APSET_G5_G8, bRFRegOffsetMask,
1877                         ((APK_result[path][1] << 15) | (APK_result[path][1] << 10) | (0x00 << 5) | 0x05));
1878                 else
1879                 PHY_SetRFReg(pAdapter, path, RF_BS_PA_APSET_G5_G8, bRFRegOffsetMask,
1880                         ((APK_result[path][1] << 15) | (APK_result[path][1] << 10) | (0x02 << 5) | 0x05));
1881
1882                 PHY_SetRFReg(pAdapter, path, RF_BS_PA_APSET_G9_G11, bRFRegOffsetMask, ((0x08 << 15) | (0x08 << 10) | (0x08 << 5) | 0x08));
1883         }
1884
1885         pHalData->bAPKdone = TRUE;
1886
1887         RTPRINT(FINIT, INIT_IQK, ("<==phy_APCalibrate_8192C()\n"));
1888 }
1889
1890
1891 VOID
1892 PHY_IQCalibrate_8192C(
1893         IN      PADAPTER        pAdapter,
1894         IN      BOOLEAN         bReCovery
1895         )
1896 {
1897         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1898         s4Byte                  result[4][8];   //last is final result
1899         u1Byte                  i, final_candidate, Indexforchannel;
1900         BOOLEAN                 bPathAOK, bPathBOK;
1901         s4Byte                  RegE94, RegE9C, RegEA4, RegEAC, RegEB4, RegEBC, RegEC4, RegECC, RegTmp = 0;
1902         BOOLEAN                 is12simular, is13simular, is23simular;
1903         BOOLEAN                 bStartContTx = FALSE, bSingleTone = FALSE, bCarrierSuppression = FALSE;
1904         u4Byte                  IQK_BB_REG_92C[IQK_BB_REG_NUM] = {
1905                                         rOFDM0_XARxIQImbalance,         rOFDM0_XBRxIQImbalance,
1906                                         rOFDM0_ECCAThreshold,   rOFDM0_AGCRSSITable,
1907                                         rOFDM0_XATxIQImbalance,         rOFDM0_XBTxIQImbalance,
1908                                         rOFDM0_XCTxAFE,                         rOFDM0_XDTxAFE,
1909                                         rOFDM0_RxIQExtAnta};
1910
1911         if (ODM_CheckPowerStatus(pAdapter) == FALSE)
1912                 return;
1913
1914 #if MP_DRIVER == 1
1915         bStartContTx = pAdapter->MptCtx.bStartContTx;
1916         bSingleTone = pAdapter->MptCtx.bSingleTone;
1917         bCarrierSuppression = pAdapter->MptCtx.bCarrierSuppression;
1918 #endif
1919
1920         //ignore IQK when continuous Tx
1921         if(bStartContTx || bSingleTone || bCarrierSuppression)
1922                 return;
1923
1924 #ifdef DISABLE_BB_RF
1925         return;
1926 #endif
1927         if(pAdapter->bSlaveOfDMSP)
1928                 return;
1929
1930         if (bReCovery)
1931                 {
1932                         phy_ReloadADDARegisters(pAdapter, IQK_BB_REG_92C, pHalData->IQK_BB_backup_recover, 9);
1933                         return;
1934
1935                 }
1936
1937         RTPRINT(FINIT, INIT_IQK, ("IQK:Start!!!\n"));
1938
1939         for(i = 0; i < 8; i++)
1940         {
1941                 result[0][i] = 0;
1942                 result[1][i] = 0;
1943                 result[2][i] = 0;
1944                 result[3][i] = 0;
1945         }
1946         final_candidate = 0xff;
1947         bPathAOK = FALSE;
1948         bPathBOK = FALSE;
1949         is12simular = FALSE;
1950         is23simular = FALSE;
1951         is13simular = FALSE;
1952
1953         AcquireCCKAndRWPageAControl(pAdapter);
1954         /*RT_TRACE(COMP_INIT,DBG_LOUD,("Acquire Mutex in IQCalibrate\n"));*/
1955         for (i=0; i<3; i++)
1956         {
1957                 /*For 88C 1T1R*/
1958                 phy_IQCalibrate_8192C(pAdapter, result, i, FALSE);
1959
1960                 if(i == 1)
1961                 {
1962                         is12simular = phy_SimularityCompare(pAdapter, result, 0, 1);
1963                         if(is12simular)
1964                         {
1965                                 final_candidate = 0;
1966                                 break;
1967                         }
1968                 }
1969
1970                 if(i == 2)
1971                 {
1972                         is13simular = phy_SimularityCompare(pAdapter, result, 0, 2);
1973                         if(is13simular)
1974                         {
1975                                 final_candidate = 0;
1976                                 break;
1977                         }
1978
1979                         is23simular = phy_SimularityCompare(pAdapter, result, 1, 2);
1980                         if(is23simular)
1981                                 final_candidate = 1;
1982                         else
1983                         {
1984                                 for(i = 0; i < 8; i++)
1985                                         RegTmp += result[3][i];
1986
1987                                 if(RegTmp != 0)
1988                                         final_candidate = 3;
1989                                 else
1990                                         final_candidate = 0xFF;
1991                         }
1992                 }
1993         }
1994 //      RT_TRACE(COMP_INIT,DBG_LOUD,("Release Mutex in IQCalibrate \n"));
1995         ReleaseCCKAndRWPageAControl(pAdapter);
1996
1997         for (i=0; i<4; i++)
1998         {
1999                 RegE94 = result[i][0];
2000                 RegE9C = result[i][1];
2001                 RegEA4 = result[i][2];
2002                 RegEAC = result[i][3];
2003                 RegEB4 = result[i][4];
2004                 RegEBC = result[i][5];
2005                 RegEC4 = result[i][6];
2006                 RegECC = result[i][7];
2007                 RTPRINT(FINIT, INIT_IQK, ("IQK: RegE94=%x RegE9C=%x RegEA4=%x RegEAC=%x RegEB4=%x RegEBC=%x RegEC4=%x RegECC=%x\n ", RegE94, RegE9C, RegEA4, RegEAC, RegEB4, RegEBC, RegEC4, RegECC));
2008         }
2009
2010         if(final_candidate != 0xff)
2011         {
2012                 pHalData->RegE94 = RegE94 = result[final_candidate][0];
2013                 pHalData->RegE9C = RegE9C = result[final_candidate][1];
2014                 RegEA4 = result[final_candidate][2];
2015                 RegEAC = result[final_candidate][3];
2016                 pHalData->RegEB4 = RegEB4 = result[final_candidate][4];
2017                 pHalData->RegEBC = RegEBC = result[final_candidate][5];
2018                 RegEC4 = result[final_candidate][6];
2019                 RegECC = result[final_candidate][7];
2020                 RTPRINT(FINIT, INIT_IQK, ("IQK: final_candidate is %x\n",final_candidate));
2021                 RTPRINT(FINIT, INIT_IQK, ("IQK: RegE94=%x RegE9C=%x RegEA4=%x RegEAC=%x RegEB4=%x RegEBC=%x RegEC4=%x RegECC=%x\n ", RegE94, RegE9C, RegEA4, RegEAC, RegEB4, RegEBC, RegEC4, RegECC));
2022                 bPathAOK = bPathBOK = TRUE;
2023         }
2024         else
2025         {
2026                 RegE94 = RegEB4 = pHalData->RegE94 = pHalData->RegEB4 = 0x100;  //X default value
2027                 RegE9C = RegEBC = pHalData->RegE9C = pHalData->RegEBC = 0x0;            //Y default value
2028         }
2029
2030         if((RegE94 != 0)/*&&(RegEA4 != 0)*/)
2031         {
2032                 if(pHalData->CurrentBandType == BAND_ON_5G)
2033                         phy_PathAFillIQKMatrix_5G_Normal(pAdapter, bPathAOK, result, final_candidate, (RegEA4 == 0));
2034                 else
2035                         phy_PathAFillIQKMatrix(pAdapter, bPathAOK, result, final_candidate, (RegEA4 == 0));
2036
2037         }
2038
2039         if (IS_92C_SERIAL(pHalData->VersionID) || IS_92D_SINGLEPHY(pHalData->VersionID))
2040         {
2041                 if((RegEB4 != 0)/*&&(RegEC4 != 0)*/)
2042                 {
2043                         if(pHalData->CurrentBandType == BAND_ON_5G)
2044                                 phy_PathBFillIQKMatrix_5G_Normal(pAdapter, bPathBOK, result, final_candidate, (RegEC4 == 0));
2045                         else
2046                                 phy_PathBFillIQKMatrix(pAdapter, bPathBOK, result, final_candidate, (RegEC4 == 0));
2047                 }
2048         }
2049
2050         phy_SaveADDARegisters(pAdapter, IQK_BB_REG_92C, pHalData->IQK_BB_backup_recover, 9);
2051
2052 }
2053
2054
2055 VOID
2056 PHY_LCCalibrate_8192C(
2057         IN      PADAPTER        pAdapter
2058         )
2059 {
2060         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
2061         BOOLEAN                 bStartContTx = FALSE, bSingleTone = FALSE, bCarrierSuppression = FALSE;
2062         PMGNT_INFO              pMgntInfo=&pAdapter->MgntInfo;
2063         PMGNT_INFO              pMgntInfoBuddyAdapter;
2064         u4Byte                  timeout = 2000, timecount = 0;
2065         PADAPTER        BuddyAdapter = pAdapter->BuddyAdapter;
2066
2067 #if MP_DRIVER == 1
2068         bStartContTx = pAdapter->MptCtx.bStartContTx;
2069         bSingleTone = pAdapter->MptCtx.bSingleTone;
2070         bCarrierSuppression = pAdapter->MptCtx.bCarrierSuppression;
2071 #endif
2072
2073 #ifdef DISABLE_BB_RF
2074         return;
2075 #endif
2076
2077         //ignore LCK when continuous Tx
2078         if(bStartContTx || bSingleTone || bCarrierSuppression)
2079                 return;
2080
2081         if(BuddyAdapter != NULL &&
2082                 ((pAdapter->interfaceIndex == 0 && pHalData->CurrentBandType == BAND_ON_2_4G) ||
2083                 (pAdapter->interfaceIndex == 1 && pHalData->CurrentBandType == BAND_ON_5G)))
2084         {
2085                 pMgntInfoBuddyAdapter=&BuddyAdapter->MgntInfo;
2086                 while(pMgntInfoBuddyAdapter->bScanInProgress && timecount < timeout)
2087                 {
2088                         delay_ms(50);
2089                         timecount += 50;
2090                 }
2091         }
2092
2093         while(pMgntInfo->bScanInProgress && timecount < timeout)
2094         {
2095                 delay_ms(50);
2096                 timecount += 50;
2097         }
2098
2099         pHalData->bLCKInProgress = TRUE;
2100
2101         RTPRINT(FINIT, INIT_IQK, ("LCK:Start!!!interface %d currentband %x delay %d ms\n", pAdapter->interfaceIndex, pHalData->CurrentBandType, timecount));
2102
2103         //if(IS_92C_SERIAL(pHalData->VersionID) || IS_92D_SINGLEPHY(pHalData->VersionID))
2104         if(IS_2T2R(pHalData->VersionID))
2105         {
2106                 phy_LCCalibrate(pAdapter, TRUE);
2107         }
2108         else{
2109                 // For 88C 1T1R
2110                 phy_LCCalibrate(pAdapter, FALSE);
2111         }
2112
2113         pHalData->bLCKInProgress = FALSE;
2114
2115         RTPRINT(FINIT, INIT_IQK, ("LCK:Finish!!!interface %d\n", pAdapter->interfaceIndex));
2116
2117
2118 }
2119
2120 VOID
2121 PHY_APCalibrate_8192C(
2122         IN      PADAPTER        pAdapter,
2123         IN      s1Byte          delta
2124         )
2125 {
2126         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
2127
2128         //default disable APK, because Tx NG issue, suggest by Jenyu, 2011.11.25
2129         return;
2130
2131 #ifdef DISABLE_BB_RF
2132         return;
2133 #endif
2134
2135 #if FOR_BRAZIL_PRETEST != 1
2136         if(pHalData->bAPKdone)
2137 #endif
2138                 return;
2139
2140         if(IS_92C_SERIAL( pHalData->VersionID)){
2141                 phy_APCalibrate_8192C(pAdapter, delta, TRUE);
2142         }
2143         else{
2144                 // For 88C 1T1R
2145                 phy_APCalibrate_8192C(pAdapter, delta, FALSE);
2146         }
2147 }
2148
2149
2150 #endif
2151
2152
2153 //3============================================================
2154 //3 IQ Calibration
2155 //3============================================================
2156
2157 VOID
2158 ODM_ResetIQKResult(
2159         IN      PVOID           pDM_VOID
2160 )
2161 {
2162         return;
2163 }
2164 #if 1//!(DM_ODM_SUPPORT_TYPE & ODM_AP)
2165 u1Byte ODM_GetRightChnlPlaceforIQK(u1Byte chnl)
2166 {
2167         u1Byte  channel_all[ODM_TARGET_CHNL_NUM_2G_5G] =
2168         {1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,149,151,153,155,157,159,161,163,165};
2169         u1Byte  place = chnl;
2170
2171
2172         if(chnl > 14)
2173         {
2174                 for(place = 14; place<sizeof(channel_all); place++)
2175                 {
2176                         if(channel_all[place] == chnl)
2177                         {
2178                                 return place-13;
2179                         }
2180                 }
2181         }
2182         return 0;
2183
2184 }
2185 #endif
2186
2187 VOID
2188 odm_IQCalibrate(
2189                 IN      PDM_ODM_T       pDM_Odm
2190                 )
2191 {
2192         PADAPTER        Adapter = pDM_Odm->Adapter;
2193
2194 #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
2195         if (*pDM_Odm->pIsFcsModeEnable)
2196                 return;
2197 #endif
2198
2199 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
2200         if (!IS_HARDWARE_TYPE_JAGUAR(Adapter))
2201                 return;
2202 #if (DM_ODM_SUPPORT_TYPE & (ODM_CE))
2203         else if (IS_HARDWARE_TYPE_8812AU(Adapter))
2204                 return;
2205 #endif
2206 #endif
2207
2208 #if (RTL8821A_SUPPORT == 1)
2209         if (pDM_Odm->bLinked) {
2210                 if ((*pDM_Odm->pChannel != pDM_Odm->preChannel) && (!*pDM_Odm->pbScanInProcess)) {
2211                         pDM_Odm->preChannel = *pDM_Odm->pChannel;
2212                         pDM_Odm->LinkedInterval = 0;
2213                 }
2214
2215                 if (pDM_Odm->LinkedInterval < 3)
2216                         pDM_Odm->LinkedInterval++;
2217
2218                 if (pDM_Odm->LinkedInterval == 2) {
2219                         /*Mark out IQK flow to prevent tx stuck. by Maddest 20130306*/
2220                         /*Open it verified by James 20130715*/
2221 #if (DM_ODM_SUPPORT_TYPE == ODM_CE)
2222                         PHY_IQCalibrate_8821A(pDM_Odm, FALSE);
2223 #elif (DM_ODM_SUPPORT_TYPE == ODM_WIN)
2224                         PHY_IQCalibrate(Adapter, FALSE);
2225 #else
2226                         PHY_IQCalibrate_8821A(Adapter, FALSE);
2227 #endif
2228                 }
2229         } else
2230                 pDM_Odm->LinkedInterval = 0;
2231 #endif
2232 }
2233
2234 void phydm_rf_init(IN   PVOID           pDM_VOID)
2235 {
2236         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
2237         odm_TXPowerTrackingInit(pDM_Odm);
2238
2239 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
2240         ODM_ClearTxPowerTrackingState(pDM_Odm);
2241 #endif
2242
2243 #if (DM_ODM_SUPPORT_TYPE & (ODM_AP))
2244 #if (RTL8814A_SUPPORT == 1)
2245         if (pDM_Odm->SupportICType & ODM_RTL8814A)
2246                 PHY_IQCalibrate_8814A_Init(pDM_Odm);
2247 #endif
2248 #endif
2249
2250 }
2251
2252 void phydm_rf_watchdog(IN       PVOID           pDM_VOID)
2253 {
2254         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
2255 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
2256         ODM_TXPowerTrackingCheck(pDM_Odm);
2257         if (pDM_Odm->SupportICType & ODM_IC_11AC_SERIES)
2258                 odm_IQCalibrate(pDM_Odm);
2259 #endif
2260 }