drivers/staging/rtl8192e/rtl_dm.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * This program is distributed in the hope that it will be useful, but WITHOUT
   5  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   6  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   7  * more details.
   8  *
   9  * You should have received a copy of the GNU General Public License along with
  10  * this program; if not, write to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  12  *
  13  * The full GNU General Public License is included in this distribution in the
  14  * file called LICENSE.
  15  *
  16  * Contact Information:
  17  * wlanfae <wlanfae@realtek.com>
  18 ******************************************************************************/
  19 #include "rtl_core.h"
  20 #include "rtl_dm.h"
  21 #include "r8192E_hw.h"
  22 #include "r8192E_phy.h"
  23 #include "r8192E_phyreg.h"
  24 #include "r8190P_rtl8256.h"
  25 #include "r8192E_cmdpkt.h"
  26
  27 /*---------------------------Define Local Constant---------------------------*/
  28 static u32 edca_setting_DL[HT_IOT_PEER_MAX] =
  29 { 0x5e4322,
  30    0x5e4322,
  31    0x5ea44f,
  32    0x5e4322,
  33    0x604322,
  34    0xa44f,
  35    0x5e4322,
  36    0x5e4332
  37  };
  38
  39 static u32 edca_setting_DL_GMode[HT_IOT_PEER_MAX] =
  40 { 0x5e4322,
  41    0x5e4322,
  42    0x5e4322,
  43    0x5e4322,
  44    0x604322,
  45    0xa44f,
  46    0x5e4322,
  47    0x5e4322
  48 };
  49
  50 static u32 edca_setting_UL[HT_IOT_PEER_MAX] =
  51 { 0x5e4322,
  52    0xa44f,
  53    0x5ea44f,
  54    0x5e4322,
  55    0x604322,
  56    0x5e4322,
  57    0x5e4322,
  58    0x5e4332
  59 };
  60
  61 #define RTK_UL_EDCA 0xa44f
  62 #define RTK_DL_EDCA 0x5e4322
  63 /*---------------------------Define Local Constant---------------------------*/
  64
  65
  66 /*------------------------Define global variable-----------------------------*/
  67 struct dig_t dm_digtable;
  68 u8              dm_shadow[16][256] = {{0}};
  69 struct drx_path_sel DM_RxPathSelTable;
  70 /*------------------------Define global variable-----------------------------*/
  71
  72
  73 /*------------------------Define local variable------------------------------*/
  74 /*------------------------Define local variable------------------------------*/
  75
  76
  77 /*--------------------Define export function prototype-----------------------*/
  78 extern  void    init_hal_dm(struct net_device *dev);
  79 extern  void deinit_hal_dm(struct net_device *dev);
  80
  81 extern void hal_dm_watchdog(struct net_device *dev);
  82
  83
  84 extern  void    init_rate_adaptive(struct net_device *dev);
  85 extern  void    dm_txpower_trackingcallback(void *data);
  86
  87 extern  void    dm_restore_dynamic_mechanism_state(struct net_device *dev);
  88 extern  void    dm_backup_dynamic_mechanism_state(struct net_device *dev);
  89 extern  void    dm_change_dynamic_initgain_thresh(struct net_device *dev,
  90                                                                 u32             dm_type,
  91                                                                 u32             dm_value);
  92 extern  void    DM_ChangeFsyncSetting(struct net_device *dev,
  93                                                                                                 s32             DM_Type,
  94                                                                                                 s32             DM_Value);
  95 extern  void dm_force_tx_fw_info(struct net_device *dev,
  96                                                                                 u32             force_type,
  97                                                                                 u32             force_value);
  98 extern  void    dm_init_edca_turbo(struct net_device *dev);
  99 extern  void    dm_rf_operation_test_callback(unsigned long data);
 100 extern  void    dm_rf_pathcheck_workitemcallback(void *data);
 101 extern  void dm_fsync_timer_callback(unsigned long data);
 102 extern  void dm_check_fsync(struct net_device *dev);
 103 extern  void    dm_shadow_init(struct net_device *dev);
 104 extern  void dm_initialize_txpower_tracking(struct net_device *dev);
 105
 106 extern  void    dm_CheckRfCtrlGPIO(void *data);
 107
 108
 109 /*--------------------Define export function prototype-----------------------*/
 110
 111
 112 /*---------------------Define local function prototype-----------------------*/
 113 static  void    dm_check_rate_adaptive(struct net_device *dev);
 114
 115 static  void    dm_init_bandwidth_autoswitch (struct net_device *dev);
 116 static  void    dm_bandwidth_autoswitch (       struct net_device *dev);
 117
 118
 119 static  void    dm_check_txpower_tracking(struct net_device *dev);
 120
 121
 122
 123
 124
 125 static  void    dm_bb_initialgain_restore(struct net_device *dev);
 126
 127
 128 static  void    dm_bb_initialgain_backup(struct net_device *dev);
 129
 130 static  void dm_dig_init(struct net_device *dev);
 131 static  void dm_ctrl_initgain_byrssi(struct net_device *dev);
 132 static  void dm_ctrl_initgain_byrssi_highpwr(struct net_device *dev);
 133 static  void dm_ctrl_initgain_byrssi_by_driverrssi(     struct net_device *dev);
 134 static  void dm_ctrl_initgain_byrssi_by_fwfalse_alarm(struct net_device *dev);
 135 static  void dm_initial_gain(struct net_device *dev);
 136 static  void dm_pd_th(struct net_device *dev);
 137 static  void dm_cs_ratio(struct net_device *dev);
 138
 139 static  void dm_init_ctstoself(struct net_device *dev);
 140 static  void dm_Init_WA_Broadcom_IOT(struct net_device *dev);
 141
 142 static  void    dm_check_edca_turbo(struct net_device *dev);
 143
 144 static  void dm_check_pbc_gpio(struct net_device *dev);
 145
 146
 147 static  void dm_check_rx_path_selection(struct net_device *dev);
 148 static  void dm_init_rxpath_selection(struct net_device *dev);
 149 static  void dm_rxpath_sel_byrssi(struct net_device *dev);
 150
 151
 152 static void dm_init_fsync(struct net_device *dev);
 153 static void dm_deInit_fsync(struct net_device *dev);
 154
 155 static  void dm_check_txrateandretrycount(struct net_device *dev);
 156 static  void dm_check_ac_dc_power(struct net_device *dev);
 157
 158 /*---------------------Define local function prototype-----------------------*/
 159
 160 static  void    dm_init_dynamic_txpower(struct net_device *dev);
 161 static  void    dm_dynamic_txpower(struct net_device *dev);
 162
 163
 164 static  void dm_send_rssi_tofw(struct net_device *dev);
 165 static  void    dm_ctstoself(struct net_device *dev);
 166 /*---------------------------Define function prototype------------------------*/
 167
 168 extern  void
 169 init_hal_dm(struct net_device *dev)
 170 {
 171         struct r8192_priv *priv = rtllib_priv(dev);
 172         priv->DM_Type = DM_Type_ByDriver;
 173
 174         priv->undecorated_smoothed_pwdb = -1;
 175
 176         dm_init_dynamic_txpower(dev);
 177
 178         init_rate_adaptive(dev);
 179
 180         dm_dig_init(dev);
 181         dm_init_edca_turbo(dev);
 182         dm_init_bandwidth_autoswitch (dev);
 183         dm_init_fsync(dev);
 184         dm_init_rxpath_selection(dev);
 185         dm_init_ctstoself(dev);
 186         if (IS_HARDWARE_TYPE_8192SE(dev))
 187         dm_Init_WA_Broadcom_IOT(dev);
 188
 189         INIT_DELAYED_WORK_RSL(&priv->gpio_change_rf_wq, (void *)dm_CheckRfCtrlGPIO,dev);
 190 }
 191
 192 extern void deinit_hal_dm(struct net_device *dev)
 193 {
 194
 195         dm_deInit_fsync(dev);
 196
 197 }
 198
 199 extern  void    hal_dm_watchdog(struct net_device *dev)
 200 {
 201         struct r8192_priv *priv = rtllib_priv(dev);
 202         if (priv->being_init_adapter)
 203                 return;
 204
 205         dm_check_ac_dc_power(dev);
 206
 207         dm_check_pbc_gpio(dev);
 208         dm_check_txrateandretrycount(dev);
 209         dm_check_edca_turbo(dev);
 210
 211         dm_check_rate_adaptive(dev);
 212         dm_dynamic_txpower(dev);
 213         dm_check_txpower_tracking(dev);
 214
 215         dm_ctrl_initgain_byrssi(dev);
 216         dm_bandwidth_autoswitch (dev);
 217
 218         dm_check_rx_path_selection(dev);
 219         dm_check_fsync(dev);
 220
 221         dm_send_rssi_tofw(dev);
 222         dm_ctstoself(dev);
 223 }
 224
 225 void dm_check_ac_dc_power(struct net_device *dev)
 226 {
 227         struct r8192_priv *priv = rtllib_priv(dev);
 228         static char *ac_dc_check_script_path = "/etc/acpi/wireless-rtl-ac-dc-power.sh";
 229         char *argv[] = {ac_dc_check_script_path,DRV_NAME,NULL};
 230         static char *envp[] = {"HOME=/",
 231                         "TERM=linux",
 232                         "PATH=/usr/bin:/bin",
 233                          NULL};
 234
 235         if (priv->ResetProgress == RESET_TYPE_SILENT)
 236         {
 237                 RT_TRACE((COMP_INIT | COMP_POWER | COMP_RF), "GPIOChangeRFWorkItemCallBack(): Silent Reseting!!!!!!!\n");
 238                 return;
 239         }
 240
 241         if (priv->rtllib->state != RTLLIB_LINKED) {
 242                 return;
 243         }
 244         call_usermodehelper(ac_dc_check_script_path,argv,envp,1);
 245
 246         return;
 247 };
 248
 249
 250 extern void init_rate_adaptive(struct net_device * dev)
 251 {
 252
 253         struct r8192_priv *priv = rtllib_priv(dev);
 254         struct rate_adaptive *pra = (struct rate_adaptive *)&priv->rate_adaptive;
 255
 256         pra->ratr_state = DM_RATR_STA_MAX;
 257         pra->high2low_rssi_thresh_for_ra = RateAdaptiveTH_High;
 258         pra->low2high_rssi_thresh_for_ra20M = RateAdaptiveTH_Low_20M+5;
 259         pra->low2high_rssi_thresh_for_ra40M = RateAdaptiveTH_Low_40M+5;
 260
 261         pra->high_rssi_thresh_for_ra = RateAdaptiveTH_High+5;
 262         pra->low_rssi_thresh_for_ra20M = RateAdaptiveTH_Low_20M;
 263         pra->low_rssi_thresh_for_ra40M = RateAdaptiveTH_Low_40M;
 264
 265         if (priv->CustomerID == RT_CID_819x_Netcore)
 266                 pra->ping_rssi_enable = 1;
 267         else
 268                 pra->ping_rssi_enable = 0;
 269         pra->ping_rssi_thresh_for_ra = 15;
 270
 271
 272         if (priv->rf_type == RF_2T4R)
 273         {
 274                 pra->upper_rssi_threshold_ratr          =       0x8f0f0000;
 275                 pra->middle_rssi_threshold_ratr         =       0x8f0ff000;
 276                 pra->low_rssi_threshold_ratr            =       0x8f0ff001;
 277                 pra->low_rssi_threshold_ratr_40M        =       0x8f0ff005;
 278                 pra->low_rssi_threshold_ratr_20M        =       0x8f0ff001;
 279                 pra->ping_rssi_ratr     =       0x0000000d;
 280         }
 281         else if (priv->rf_type == RF_1T2R)
 282         {
 283                 pra->upper_rssi_threshold_ratr          =       0x000fc000;
 284                 pra->middle_rssi_threshold_ratr         =       0x000ff000;
 285                 pra->low_rssi_threshold_ratr            =       0x000ff001;
 286                 pra->low_rssi_threshold_ratr_40M        =       0x000ff005;
 287                 pra->low_rssi_threshold_ratr_20M        =       0x000ff001;
 288                 pra->ping_rssi_ratr     =       0x0000000d;
 289         }
 290
 291 }
 292
 293
 294 static void dm_check_rate_adaptive(struct net_device * dev)
 295 {
 296         struct r8192_priv *priv = rtllib_priv(dev);
 297         struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
 298         struct rate_adaptive *pra = (struct rate_adaptive *)&priv->rate_adaptive;
 299         u32                                             currentRATR, targetRATR = 0;
 300         u32                                             LowRSSIThreshForRA = 0, HighRSSIThreshForRA = 0;
 301         bool                                            bshort_gi_enabled = false;
 302         static u8                                       ping_rssi_state=0;
 303
 304         if (IS_NIC_DOWN(priv)){
 305                 RT_TRACE(COMP_RATE, "<---- dm_check_rate_adaptive(): driver is going to unload\n");
 306                 return;
 307         }
 308
 309         if (pra->rate_adaptive_disabled)
 310                 return;
 311
 312         if ( !(priv->rtllib->mode == WIRELESS_MODE_N_24G ||
 313                  priv->rtllib->mode == WIRELESS_MODE_N_5G))
 314                  return;
 315
 316         if ( priv->rtllib->state == RTLLIB_LINKED )
 317         {
 318
 319                 bshort_gi_enabled = (pHTInfo->bCurTxBW40MHz && pHTInfo->bCurShortGI40MHz) ||
 320                         (!pHTInfo->bCurTxBW40MHz && pHTInfo->bCurShortGI20MHz);
 321
 322
 323                 pra->upper_rssi_threshold_ratr =
 324                                 (pra->upper_rssi_threshold_ratr & (~BIT31)) | ((bshort_gi_enabled)? BIT31:0) ;
 325
 326                 pra->middle_rssi_threshold_ratr =
 327                                 (pra->middle_rssi_threshold_ratr & (~BIT31)) | ((bshort_gi_enabled)? BIT31:0) ;
 328
 329                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
 330                 {
 331                         pra->low_rssi_threshold_ratr =
 332                                 (pra->low_rssi_threshold_ratr_40M & (~BIT31)) | ((bshort_gi_enabled)? BIT31:0) ;
 333                 }
 334                 else
 335                 {
 336                         pra->low_rssi_threshold_ratr =
 337                         (pra->low_rssi_threshold_ratr_20M & (~BIT31)) | ((bshort_gi_enabled)? BIT31:0) ;
 338                 }
 339                 pra->ping_rssi_ratr =
 340                                 (pra->ping_rssi_ratr & (~BIT31)) | ((bshort_gi_enabled)? BIT31:0) ;
 341
 342                 if (pra->ratr_state == DM_RATR_STA_HIGH)
 343                 {
 344                         HighRSSIThreshForRA     = pra->high2low_rssi_thresh_for_ra;
 345                         LowRSSIThreshForRA      = (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)?
 346                                         (pra->low_rssi_thresh_for_ra40M):(pra->low_rssi_thresh_for_ra20M);
 347                 }
 348                 else if (pra->ratr_state == DM_RATR_STA_LOW)
 349                 {
 350                         HighRSSIThreshForRA     = pra->high_rssi_thresh_for_ra;
 351                         LowRSSIThreshForRA      = (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)?
 352                                         (pra->low2high_rssi_thresh_for_ra40M):(pra->low2high_rssi_thresh_for_ra20M);
 353                 }
 354                 else
 355                 {
 356                         HighRSSIThreshForRA     = pra->high_rssi_thresh_for_ra;
 357                         LowRSSIThreshForRA      = (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)?
 358                                         (pra->low_rssi_thresh_for_ra40M):(pra->low_rssi_thresh_for_ra20M);
 359                 }
 360
 361                 if (priv->undecorated_smoothed_pwdb >= (long)HighRSSIThreshForRA)
 362                 {
 363                         pra->ratr_state = DM_RATR_STA_HIGH;
 364                         targetRATR = pra->upper_rssi_threshold_ratr;
 365                 }else if (priv->undecorated_smoothed_pwdb >= (long)LowRSSIThreshForRA)
 366                 {
 367                         pra->ratr_state = DM_RATR_STA_MIDDLE;
 368                         targetRATR = pra->middle_rssi_threshold_ratr;
 369                 }else
 370                 {
 371                         pra->ratr_state = DM_RATR_STA_LOW;
 372                         targetRATR = pra->low_rssi_threshold_ratr;
 373                 }
 374
 375                 if (pra->ping_rssi_enable)
 376                 {
 377                         if (priv->undecorated_smoothed_pwdb < (long)(pra->ping_rssi_thresh_for_ra+5))
 378                         {
 379                                 if ( (priv->undecorated_smoothed_pwdb < (long)pra->ping_rssi_thresh_for_ra) ||
 380                                         ping_rssi_state )
 381                                 {
 382                                         pra->ratr_state = DM_RATR_STA_LOW;
 383                                         targetRATR = pra->ping_rssi_ratr;
 384                                         ping_rssi_state = 1;
 385                                 }
 386                         }
 387                         else
 388                         {
 389                                 ping_rssi_state = 0;
 390                         }
 391                 }
 392
 393                 if (priv->rtllib->GetHalfNmodeSupportByAPsHandler(dev))
 394                         targetRATR &=  0xf00fffff;
 395
 396                 currentRATR = read_nic_dword(dev, RATR0);
 397                 if ( targetRATR !=  currentRATR )
 398                 {
 399                         u32 ratr_value;
 400                         ratr_value = targetRATR;
 401                         RT_TRACE(COMP_RATE,"currentRATR = %x, targetRATR = %x\n", currentRATR, targetRATR);
 402                         if (priv->rf_type == RF_1T2R)
 403                         {
 404                                 ratr_value &= ~(RATE_ALL_OFDM_2SS);
 405                         }
 406                         write_nic_dword(dev, RATR0, ratr_value);
 407                         write_nic_byte(dev, UFWP, 1);
 408
 409                         pra->last_ratr = targetRATR;
 410                 }
 411
 412         }
 413         else
 414         {
 415                 pra->ratr_state = DM_RATR_STA_MAX;
 416         }
 417
 418 }
 419
 420 static void dm_init_bandwidth_autoswitch (struct net_device * dev)
 421 {
 422         struct r8192_priv *priv = rtllib_priv(dev);
 423
 424         priv->rtllib->bandwidth_auto_switch.threshold_20Mhzto40Mhz = BW_AUTO_SWITCH_LOW_HIGH;
 425         priv->rtllib->bandwidth_auto_switch.threshold_40Mhzto20Mhz = BW_AUTO_SWITCH_HIGH_LOW;
 426         priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = false;
 427         priv->rtllib->bandwidth_auto_switch.bautoswitch_enable = false;
 428
 429 }
 430
 431
 432 static void dm_bandwidth_autoswitch (struct net_device * dev)
 433 {
 434         struct r8192_priv *priv = rtllib_priv(dev);
 435
 436         if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 ||!priv->rtllib->bandwidth_auto_switch.bautoswitch_enable){
 437                 return;
 438         }else{
 439                 if (priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz == false){
 440                         if (priv->undecorated_smoothed_pwdb <= priv->rtllib->bandwidth_auto_switch.threshold_40Mhzto20Mhz)
 441                                 priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = true;
 442                 }else{
 443                         if (priv->undecorated_smoothed_pwdb >= priv->rtllib->bandwidth_auto_switch.threshold_20Mhzto40Mhz)
 444                                 priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = false;
 445
 446                 }
 447         }
 448 }
 449
 450 static u32 OFDMSwingTable[OFDM_Table_Length] = {
 451         0x7f8001fe,
 452         0x71c001c7,
 453         0x65400195,
 454         0x5a400169,
 455         0x50800142,
 456         0x47c0011f,
 457         0x40000100,
 458         0x390000e4,
 459         0x32c000cb,
 460         0x2d4000b5,
 461         0x288000a2,
 462         0x24000090,
 463         0x20000080,
 464         0x1c800072,
 465         0x19800066,
 466         0x26c0005b,
 467         0x24400051,
 468         0x12000048,
 469         0x10000040
 470 };
 471 static u8       CCKSwingTable_Ch1_Ch13[CCK_Table_length][8] = {
 472         {0x36, 0x35, 0x2e, 0x25, 0x1c, 0x12, 0x09, 0x04},
 473         {0x30, 0x2f, 0x29, 0x21, 0x19, 0x10, 0x08, 0x03},
 474         {0x2b, 0x2a, 0x25, 0x1e, 0x16, 0x0e, 0x07, 0x03},
 475         {0x26, 0x25, 0x21, 0x1b, 0x14, 0x0d, 0x06, 0x03},
 476         {0x22, 0x21, 0x1d, 0x18, 0x11, 0x0b, 0x06, 0x02},
 477         {0x1f, 0x1e, 0x1a, 0x15, 0x10, 0x0a, 0x05, 0x02},
 478         {0x1b, 0x1a, 0x17, 0x13, 0x0e, 0x09, 0x04, 0x02},
 479         {0x18, 0x17, 0x15, 0x11, 0x0c, 0x08, 0x04, 0x02},
 480         {0x16, 0x15, 0x12, 0x0f, 0x0b, 0x07, 0x04, 0x01},
 481         {0x13, 0x13, 0x10, 0x0d, 0x0a, 0x06, 0x03, 0x01},
 482         {0x11, 0x11, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01},
 483         {0x0f, 0x0f, 0x0d, 0x0b, 0x08, 0x05, 0x03, 0x01}
 484 };
 485
 486 static u8       CCKSwingTable_Ch14[CCK_Table_length][8] = {
 487         {0x36, 0x35, 0x2e, 0x1b, 0x00, 0x00, 0x00, 0x00},
 488         {0x30, 0x2f, 0x29, 0x18, 0x00, 0x00, 0x00, 0x00},
 489         {0x2b, 0x2a, 0x25, 0x15, 0x00, 0x00, 0x00, 0x00},
 490         {0x26, 0x25, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00},
 491         {0x22, 0x21, 0x1d, 0x11, 0x00, 0x00, 0x00, 0x00},
 492         {0x1f, 0x1e, 0x1a, 0x0f, 0x00, 0x00, 0x00, 0x00},
 493         {0x1b, 0x1a, 0x17, 0x0e, 0x00, 0x00, 0x00, 0x00},
 494         {0x18, 0x17, 0x15, 0x0c, 0x00, 0x00, 0x00, 0x00},
 495         {0x16, 0x15, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00},
 496         {0x13, 0x13, 0x10, 0x0a, 0x00, 0x00, 0x00, 0x00},
 497         {0x11, 0x11, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00},
 498         {0x0f, 0x0f, 0x0d, 0x08, 0x00, 0x00, 0x00, 0x00}
 499 };
 500 #define         Pw_Track_Flag                           0x11d
 501 #define         Tssi_Mea_Value                          0x13c
 502 #define         Tssi_Report_Value1                      0x134
 503 #define         Tssi_Report_Value2                      0x13e
 504 #define         FW_Busy_Flag                            0x13f
 505
 506 static void dm_TXPowerTrackingCallback_TSSI(struct net_device * dev)
 507         {
 508         struct r8192_priv *priv = rtllib_priv(dev);
 509         bool                                            bHighpowerstate, viviflag = false;
 510         struct dcmd_txcmd tx_cmd;
 511         u8                                      powerlevelOFDM24G;
 512         int                                     i =0, j = 0, k = 0;
 513         u8                                              RF_Type, tmp_report[5]={0, 0, 0, 0, 0};
 514         u32                                             Value;
 515         u8                                              Pwr_Flag;
 516         u16                                     Avg_TSSI_Meas, TSSI_13dBm, Avg_TSSI_Meas_from_driver=0;
 517         u32                                             delta=0;
 518         RT_TRACE(COMP_POWER_TRACKING,"%s()\n",__func__);
 519         write_nic_byte(dev, Pw_Track_Flag, 0);
 520         write_nic_byte(dev, FW_Busy_Flag, 0);
 521         priv->rtllib->bdynamic_txpower_enable = false;
 522         bHighpowerstate = priv->bDynamicTxHighPower;
 523
 524         powerlevelOFDM24G = (u8)(priv->Pwr_Track>>24);
 525         RF_Type = priv->rf_type;
 526         Value = (RF_Type<<8) | powerlevelOFDM24G;
 527
 528         RT_TRACE(COMP_POWER_TRACKING, "powerlevelOFDM24G = %x\n", powerlevelOFDM24G);
 529
 530
 531         for (j = 0; j<=30; j++)
 532 {
 533
 534         tx_cmd.Op               = TXCMD_SET_TX_PWR_TRACKING;
 535         tx_cmd.Length   = 4;
 536         tx_cmd.Value            = Value;
 537         cmpk_message_handle_tx(dev, (u8*)&tx_cmd, DESC_PACKET_TYPE_INIT, sizeof(struct dcmd_txcmd));
 538         mdelay(1);
 539         for (i = 0;i <= 30; i++)
 540         {
 541                 Pwr_Flag = read_nic_byte(dev, Pw_Track_Flag);
 542
 543                 if (Pwr_Flag == 0)
 544                 {
 545                         mdelay(1);
 546
 547                         if (priv->bResetInProgress)
 548                         {
 549                                 RT_TRACE(COMP_POWER_TRACKING, "we are in slient reset progress, so return\n");
 550                                 write_nic_byte(dev, Pw_Track_Flag, 0);
 551                                 write_nic_byte(dev, FW_Busy_Flag, 0);
 552                                 return;
 553                         }
 554                         if ((priv->rtllib->eRFPowerState != eRfOn))
 555                         {
 556                                 RT_TRACE(COMP_POWER_TRACKING, "we are in power save, so return\n");
 557                                 write_nic_byte(dev, Pw_Track_Flag, 0);
 558                                 write_nic_byte(dev, FW_Busy_Flag, 0);
 559                                 return;
 560                         }
 561
 562                         continue;
 563                 }
 564
 565                 Avg_TSSI_Meas = read_nic_word(dev, Tssi_Mea_Value);
 566
 567                 if (Avg_TSSI_Meas == 0)
 568                 {
 569                         write_nic_byte(dev, Pw_Track_Flag, 0);
 570                         write_nic_byte(dev, FW_Busy_Flag, 0);
 571                         return;
 572                 }
 573
 574                 for (k = 0;k < 5; k++)
 575                 {
 576                         if (k !=4)
 577                                 tmp_report[k] = read_nic_byte(dev, Tssi_Report_Value1+k);
 578                         else
 579                                 tmp_report[k] = read_nic_byte(dev, Tssi_Report_Value2);
 580
 581                         RT_TRACE(COMP_POWER_TRACKING, "TSSI_report_value = %d\n", tmp_report[k]);
 582
 583                         {
 584                                if (tmp_report[k] <= 20)
 585                                {
 586                                       viviflag =true;
 587                                       break;
 588                                }
 589                         }
 590                 }
 591
 592                 if (viviflag ==true)
 593                 {
 594                         write_nic_byte(dev, Pw_Track_Flag, 0);
 595                         viviflag = false;
 596                         RT_TRACE(COMP_POWER_TRACKING, "we filted this data\n");
 597                         for (k = 0;k < 5; k++)
 598                                 tmp_report[k] = 0;
 599                         break;
 600                 }
 601
 602                 for (k = 0;k < 5; k++)
 603                 {
 604                         Avg_TSSI_Meas_from_driver += tmp_report[k];
 605                 }
 606
 607                 Avg_TSSI_Meas_from_driver = Avg_TSSI_Meas_from_driver*100/5;
 608                 RT_TRACE(COMP_POWER_TRACKING, "Avg_TSSI_Meas_from_driver = %d\n", Avg_TSSI_Meas_from_driver);
 609                 TSSI_13dBm = priv->TSSI_13dBm;
 610                 RT_TRACE(COMP_POWER_TRACKING, "TSSI_13dBm = %d\n", TSSI_13dBm);
 611
 612                 if (Avg_TSSI_Meas_from_driver > TSSI_13dBm)
 613                         delta = Avg_TSSI_Meas_from_driver - TSSI_13dBm;
 614                 else
 615                         delta = TSSI_13dBm - Avg_TSSI_Meas_from_driver;
 616
 617                 if (delta <= E_FOR_TX_POWER_TRACK)
 618                 {
 619                         priv->rtllib->bdynamic_txpower_enable = true;
 620                         write_nic_byte(dev, Pw_Track_Flag, 0);
 621                         write_nic_byte(dev, FW_Busy_Flag, 0);
 622                         RT_TRACE(COMP_POWER_TRACKING, "tx power track is done\n");
 623                         RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex = %d\n", priv->rfa_txpowertrackingindex);
 624                         RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real = %d\n", priv->rfa_txpowertrackingindex_real);
 625                         RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference = %d\n", priv->CCKPresentAttentuation_difference);
 626                         RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation = %d\n", priv->CCKPresentAttentuation);
 627                         return;
 628                 }
 629                 else
 630                 {
 631                         if (Avg_TSSI_Meas_from_driver < TSSI_13dBm - E_FOR_TX_POWER_TRACK)
 632                         {
 633                                 if (RF_Type == RF_2T4R)
 634                                 {
 635
 636                                                 if ((priv->rfa_txpowertrackingindex > 0) &&(priv->rfc_txpowertrackingindex > 0))
 637                                 {
 638                                         priv->rfa_txpowertrackingindex--;
 639                                         if (priv->rfa_txpowertrackingindex_real > 4)
 640                                         {
 641                                                 priv->rfa_txpowertrackingindex_real--;
 642                                                 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
 643                                         }
 644
 645                                         priv->rfc_txpowertrackingindex--;
 646                                         if (priv->rfc_txpowertrackingindex_real > 4)
 647                                         {
 648                                                 priv->rfc_txpowertrackingindex_real--;
 649                                                 rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfc_txpowertrackingindex_real].txbbgain_value);
 650                                         }
 651                                                 }
 652                                                 else
 653                                                 {
 654                                                                 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
 655                                                                 rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
 656                                 }
 657                         }
 658                         else
 659                         {
 660                                                 {
 661                                                                 {
 662                                                                         if (priv->rfa_txpowertrackingindex > 0)
 663                                                                         {
 664                                                                                 priv->rfa_txpowertrackingindex--;
 665                                                                                 if (priv->rfa_txpowertrackingindex_real > 4)
 666                                                                                 {
 667                                                                                         priv->rfa_txpowertrackingindex_real--;
 668                                                                                         rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
 669                                                                                 }
 670                                                                         }
 671                                                                         else
 672                                                                                         rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
 673                                                                 }
 674                                                 }
 675
 676                                 }
 677                         }
 678                         else
 679                         {
 680                                 if (RF_Type == RF_2T4R)
 681                                 {
 682                                         if ((priv->rfa_txpowertrackingindex < TxBBGainTableLength - 1) &&(priv->rfc_txpowertrackingindex < TxBBGainTableLength - 1))
 683                                 {
 684                                         priv->rfa_txpowertrackingindex++;
 685                                         priv->rfa_txpowertrackingindex_real++;
 686                                         rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
 687                                         priv->rfc_txpowertrackingindex++;
 688                                         priv->rfc_txpowertrackingindex_real++;
 689                                         rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfc_txpowertrackingindex_real].txbbgain_value);
 690                                 }
 691                                         else
 692                                         {
 693                                                 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
 694                                                 rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
 695                         }
 696                                 }
 697                                 else
 698                                 {
 699                                         {
 700                                                         {
 701                                                                 if (priv->rfa_txpowertrackingindex < (TxBBGainTableLength - 1))
 702                                                                 {
 703                                                                         priv->rfa_txpowertrackingindex++;
 704                                                                         priv->rfa_txpowertrackingindex_real++;
 705                                                                         rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
 706                         }
 707                                                                 else
 708                                                                         rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
 709                                                         }
 710                                         }
 711                                 }
 712                         }
 713                         if (RF_Type == RF_2T4R){
 714                         priv->CCKPresentAttentuation_difference
 715                                 = priv->rfa_txpowertrackingindex - priv->rfa_txpowertracking_default;
 716                         }else{
 717                                 {
 718                                                 priv->CCKPresentAttentuation_difference
 719                                                         = priv->rfa_txpowertrackingindex_real - priv->rfa_txpowertracking_default;
 720                                 }
 721                         }
 722
 723                         if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20)
 724                                 priv->CCKPresentAttentuation
 725                                 = priv->CCKPresentAttentuation_20Mdefault + priv->CCKPresentAttentuation_difference;
 726                         else
 727                                 priv->CCKPresentAttentuation
 728                                 = priv->CCKPresentAttentuation_40Mdefault + priv->CCKPresentAttentuation_difference;
 729
 730                         if (priv->CCKPresentAttentuation > (CCKTxBBGainTableLength-1))
 731                                         priv->CCKPresentAttentuation = CCKTxBBGainTableLength-1;
 732                         if (priv->CCKPresentAttentuation < 0)
 733                                         priv->CCKPresentAttentuation = 0;
 734
 735                         if (priv->CCKPresentAttentuation > -1&&priv->CCKPresentAttentuation < CCKTxBBGainTableLength)
 736                         {
 737                                 if (priv->rtllib->current_network.channel == 14 && !priv->bcck_in_ch14)
 738                                 {
 739                                         priv->bcck_in_ch14 = true;
 740                                         dm_cck_txpower_adjust(dev,priv->bcck_in_ch14);
 741                                 }
 742                                 else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14)
 743                                 {
 744                                         priv->bcck_in_ch14 = false;
 745                                         dm_cck_txpower_adjust(dev,priv->bcck_in_ch14);
 746                                 }
 747                                 else
 748                                         dm_cck_txpower_adjust(dev,priv->bcck_in_ch14);
 749                         }
 750                 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex = %d\n", priv->rfa_txpowertrackingindex);
 751                 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real = %d\n", priv->rfa_txpowertrackingindex_real);
 752                 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference = %d\n", priv->CCKPresentAttentuation_difference);
 753                 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation = %d\n", priv->CCKPresentAttentuation);
 754
 755                 if (priv->CCKPresentAttentuation_difference <= -12||priv->CCKPresentAttentuation_difference >= 24)
 756                 {
 757                         priv->rtllib->bdynamic_txpower_enable = true;
 758                         write_nic_byte(dev, Pw_Track_Flag, 0);
 759                         write_nic_byte(dev, FW_Busy_Flag, 0);
 760                         RT_TRACE(COMP_POWER_TRACKING, "tx power track--->limited\n");
 761                         return;
 762                 }
 763
 764
 765         }
 766                 write_nic_byte(dev, Pw_Track_Flag, 0);
 767                 Avg_TSSI_Meas_from_driver = 0;
 768                 for (k = 0;k < 5; k++)
 769                         tmp_report[k] = 0;
 770                 break;
 771         }
 772         write_nic_byte(dev, FW_Busy_Flag, 0);
 773 }
 774                 priv->rtllib->bdynamic_txpower_enable = true;
 775                 write_nic_byte(dev, Pw_Track_Flag, 0);
 776 }
 777
 778 static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device * dev)
 779 {
 780 #define ThermalMeterVal 9
 781         struct r8192_priv *priv = rtllib_priv(dev);
 782         u32 tmpRegA, TempCCk;
 783         u8 tmpOFDMindex, tmpCCKindex, tmpCCK20Mindex, tmpCCK40Mindex, tmpval;
 784         int i =0, CCKSwingNeedUpdate=0;
 785
 786         if (!priv->btxpower_trackingInit)
 787         {
 788                 tmpRegA= rtl8192_QueryBBReg(dev, rOFDM0_XATxIQImbalance, bMaskDWord);
 789                 for (i=0; i<OFDM_Table_Length; i++)
 790                 {
 791                         if (tmpRegA == OFDMSwingTable[i])
 792                         {
 793                                 priv->OFDM_index[0]= (u8)i;
 794                                 RT_TRACE(COMP_POWER_TRACKING, "Initial reg0x%x = 0x%x, OFDM_index=0x%x\n",
 795                                         rOFDM0_XATxIQImbalance, tmpRegA, priv->OFDM_index[0]);
 796                         }
 797                 }
 798
 799                 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
 800                 for (i=0 ; i<CCK_Table_length ; i++)
 801                 {
 802                         if (TempCCk == (u32)CCKSwingTable_Ch1_Ch13[i][0])
 803                         {
 804                                 priv->CCK_index =(u8) i;
 805                                 RT_TRACE(COMP_POWER_TRACKING, "Initial reg0x%x = 0x%x, CCK_index=0x%x\n",
 806                                         rCCK0_TxFilter1, TempCCk, priv->CCK_index);
 807                 break;
 808         }
 809 }
 810                 priv->btxpower_trackingInit = true;
 811                 return;
 812         }
 813
 814         tmpRegA = rtl8192_phy_QueryRFReg(dev, RF90_PATH_A, 0x12, 0x078);
 815         RT_TRACE(COMP_POWER_TRACKING, "Readback ThermalMeterA = %d \n", tmpRegA);
 816         if (tmpRegA < 3 || tmpRegA > 13)
 817                 return;
 818         if (tmpRegA >= 12)
 819                 tmpRegA = 12;
 820         RT_TRACE(COMP_POWER_TRACKING, "Valid ThermalMeterA = %d \n", tmpRegA);
 821         priv->ThermalMeter[0] = ThermalMeterVal;
 822         priv->ThermalMeter[1] = ThermalMeterVal;
 823
 824         if (priv->ThermalMeter[0] >= (u8)tmpRegA)
 825         {
 826                 tmpOFDMindex = tmpCCK20Mindex = 6+(priv->ThermalMeter[0]-(u8)tmpRegA);
 827                 tmpCCK40Mindex = tmpCCK20Mindex - 6;
 828                 if (tmpOFDMindex >= OFDM_Table_Length)
 829                         tmpOFDMindex = OFDM_Table_Length-1;
 830                 if (tmpCCK20Mindex >= CCK_Table_length)
 831                         tmpCCK20Mindex = CCK_Table_length-1;
 832                 if (tmpCCK40Mindex >= CCK_Table_length)
 833                         tmpCCK40Mindex = CCK_Table_length-1;
 834         }
 835         else
 836         {
 837                 tmpval = ((u8)tmpRegA - priv->ThermalMeter[0]);
 838                 if (tmpval >= 6)
 839                         tmpOFDMindex = tmpCCK20Mindex = 0;
 840                 else
 841                         tmpOFDMindex = tmpCCK20Mindex = 6 - tmpval;
 842                 tmpCCK40Mindex = 0;
 843         }
 844         if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
 845                 tmpCCKindex = tmpCCK40Mindex;
 846         else
 847                 tmpCCKindex = tmpCCK20Mindex;
 848
 849         priv->Record_CCK_20Mindex = tmpCCK20Mindex;
 850         priv->Record_CCK_40Mindex = tmpCCK40Mindex;
 851         RT_TRACE(COMP_POWER_TRACKING, "Record_CCK_20Mindex / Record_CCK_40Mindex = %d / %d.\n",
 852                 priv->Record_CCK_20Mindex, priv->Record_CCK_40Mindex);
 853
 854         if (priv->rtllib->current_network.channel == 14 && !priv->bcck_in_ch14)
 855         {
 856                 priv->bcck_in_ch14 = true;
 857                 CCKSwingNeedUpdate = 1;
 858         }
 859         else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14)
 860         {
 861                 priv->bcck_in_ch14 = false;
 862                 CCKSwingNeedUpdate = 1;
 863         }
 864
 865         if (priv->CCK_index != tmpCCKindex)
 866 {
 867                 priv->CCK_index = tmpCCKindex;
 868                 CCKSwingNeedUpdate = 1;
 869         }
 870
 871         if (CCKSwingNeedUpdate)
 872         {
 873                 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
 874         }
 875         if (priv->OFDM_index[0] != tmpOFDMindex)
 876         {
 877                 priv->OFDM_index[0] = tmpOFDMindex;
 878                 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, OFDMSwingTable[priv->OFDM_index[0]]);
 879                 RT_TRACE(COMP_POWER_TRACKING, "Update OFDMSwing[%d] = 0x%x\n",
 880                         priv->OFDM_index[0], OFDMSwingTable[priv->OFDM_index[0]]);
 881         }
 882         priv->txpower_count = 0;
 883 }
 884
 885 void    dm_txpower_trackingcallback(void *data)
 886 {
 887         struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv,txpower_tracking_wq);
 888         struct net_device *dev = priv->rtllib->dev;
 889
 890         if (priv->IC_Cut >= IC_VersionCut_D)
 891                 dm_TXPowerTrackingCallback_TSSI(dev);
 892         else
 893                 dm_TXPowerTrackingCallback_ThermalMeter(dev);
 894 }
 895
 896 static void dm_InitializeTXPowerTracking_TSSI(struct net_device *dev)
 897 {
 898
 899         struct r8192_priv *priv = rtllib_priv(dev);
 900
 901         priv->txbbgain_table[0].txbb_iq_amplifygain =                   12;
 902         priv->txbbgain_table[0].txbbgain_value=0x7f8001fe;
 903         priv->txbbgain_table[1].txbb_iq_amplifygain =                   11;
 904         priv->txbbgain_table[1].txbbgain_value=0x788001e2;
 905         priv->txbbgain_table[2].txbb_iq_amplifygain =                   10;
 906         priv->txbbgain_table[2].txbbgain_value=0x71c001c7;
 907         priv->txbbgain_table[3].txbb_iq_amplifygain =                   9;
 908         priv->txbbgain_table[3].txbbgain_value=0x6b8001ae;
 909         priv->txbbgain_table[4].txbb_iq_amplifygain =                  8;
 910         priv->txbbgain_table[4].txbbgain_value=0x65400195;
 911         priv->txbbgain_table[5].txbb_iq_amplifygain =                  7;
 912         priv->txbbgain_table[5].txbbgain_value=0x5fc0017f;
 913         priv->txbbgain_table[6].txbb_iq_amplifygain =                  6;
 914         priv->txbbgain_table[6].txbbgain_value=0x5a400169;
 915         priv->txbbgain_table[7].txbb_iq_amplifygain =                  5;
 916         priv->txbbgain_table[7].txbbgain_value=0x55400155;
 917         priv->txbbgain_table[8].txbb_iq_amplifygain =                  4;
 918         priv->txbbgain_table[8].txbbgain_value=0x50800142;
 919         priv->txbbgain_table[9].txbb_iq_amplifygain =                  3;
 920         priv->txbbgain_table[9].txbbgain_value=0x4c000130;
 921         priv->txbbgain_table[10].txbb_iq_amplifygain =                 2;
 922         priv->txbbgain_table[10].txbbgain_value=0x47c0011f;
 923         priv->txbbgain_table[11].txbb_iq_amplifygain =                 1;
 924         priv->txbbgain_table[11].txbbgain_value=0x43c0010f;
 925         priv->txbbgain_table[12].txbb_iq_amplifygain =                 0;
 926         priv->txbbgain_table[12].txbbgain_value=0x40000100;
 927         priv->txbbgain_table[13].txbb_iq_amplifygain =                 -1;
 928         priv->txbbgain_table[13].txbbgain_value=0x3c8000f2;
 929         priv->txbbgain_table[14].txbb_iq_amplifygain =               -2;
 930         priv->txbbgain_table[14].txbbgain_value=0x390000e4;
 931         priv->txbbgain_table[15].txbb_iq_amplifygain =               -3;
 932         priv->txbbgain_table[15].txbbgain_value=0x35c000d7;
 933         priv->txbbgain_table[16].txbb_iq_amplifygain =               -4;
 934         priv->txbbgain_table[16].txbbgain_value=0x32c000cb;
 935         priv->txbbgain_table[17].txbb_iq_amplifygain =               -5;
 936         priv->txbbgain_table[17].txbbgain_value=0x300000c0;
 937         priv->txbbgain_table[18].txbb_iq_amplifygain =                      -6;
 938         priv->txbbgain_table[18].txbbgain_value=0x2d4000b5;
 939         priv->txbbgain_table[19].txbb_iq_amplifygain =               -7;
 940         priv->txbbgain_table[19].txbbgain_value=0x2ac000ab;
 941         priv->txbbgain_table[20].txbb_iq_amplifygain =               -8;
 942         priv->txbbgain_table[20].txbbgain_value=0x288000a2;
 943         priv->txbbgain_table[21].txbb_iq_amplifygain =               -9;
 944         priv->txbbgain_table[21].txbbgain_value=0x26000098;
 945         priv->txbbgain_table[22].txbb_iq_amplifygain =               -10;
 946         priv->txbbgain_table[22].txbbgain_value=0x24000090;
 947         priv->txbbgain_table[23].txbb_iq_amplifygain =               -11;
 948         priv->txbbgain_table[23].txbbgain_value=0x22000088;
 949         priv->txbbgain_table[24].txbb_iq_amplifygain =               -12;
 950         priv->txbbgain_table[24].txbbgain_value=0x20000080;
 951         priv->txbbgain_table[25].txbb_iq_amplifygain =               -13;
 952         priv->txbbgain_table[25].txbbgain_value=0x1a00006c;
 953         priv->txbbgain_table[26].txbb_iq_amplifygain =               -14;
 954         priv->txbbgain_table[26].txbbgain_value=0x1c800072;
 955         priv->txbbgain_table[27].txbb_iq_amplifygain =               -15;
 956         priv->txbbgain_table[27].txbbgain_value=0x18000060;
 957         priv->txbbgain_table[28].txbb_iq_amplifygain =               -16;
 958         priv->txbbgain_table[28].txbbgain_value=0x19800066;
 959         priv->txbbgain_table[29].txbb_iq_amplifygain =               -17;
 960         priv->txbbgain_table[29].txbbgain_value=0x15800056;
 961         priv->txbbgain_table[30].txbb_iq_amplifygain =               -18;
 962         priv->txbbgain_table[30].txbbgain_value=0x26c0005b;
 963         priv->txbbgain_table[31].txbb_iq_amplifygain =               -19;
 964         priv->txbbgain_table[31].txbbgain_value=0x14400051;
 965         priv->txbbgain_table[32].txbb_iq_amplifygain =               -20;
 966         priv->txbbgain_table[32].txbbgain_value=0x24400051;
 967         priv->txbbgain_table[33].txbb_iq_amplifygain =               -21;
 968         priv->txbbgain_table[33].txbbgain_value=0x1300004c;
 969         priv->txbbgain_table[34].txbb_iq_amplifygain =               -22;
 970         priv->txbbgain_table[34].txbbgain_value=0x12000048;
 971         priv->txbbgain_table[35].txbb_iq_amplifygain =               -23;
 972         priv->txbbgain_table[35].txbbgain_value=0x11000044;
 973         priv->txbbgain_table[36].txbb_iq_amplifygain =               -24;
 974         priv->txbbgain_table[36].txbbgain_value=0x10000040;
 975
 976         priv->cck_txbbgain_table[0].ccktxbb_valuearray[0] = 0x36;
 977         priv->cck_txbbgain_table[0].ccktxbb_valuearray[1] = 0x35;
 978         priv->cck_txbbgain_table[0].ccktxbb_valuearray[2] = 0x2e;
 979         priv->cck_txbbgain_table[0].ccktxbb_valuearray[3] = 0x25;
 980         priv->cck_txbbgain_table[0].ccktxbb_valuearray[4] = 0x1c;
 981         priv->cck_txbbgain_table[0].ccktxbb_valuearray[5] = 0x12;
 982         priv->cck_txbbgain_table[0].ccktxbb_valuearray[6] = 0x09;
 983         priv->cck_txbbgain_table[0].ccktxbb_valuearray[7] = 0x04;
 984
 985         priv->cck_txbbgain_table[1].ccktxbb_valuearray[0] = 0x33;
 986         priv->cck_txbbgain_table[1].ccktxbb_valuearray[1] = 0x32;
 987         priv->cck_txbbgain_table[1].ccktxbb_valuearray[2] = 0x2b;
 988         priv->cck_txbbgain_table[1].ccktxbb_valuearray[3] = 0x23;
 989         priv->cck_txbbgain_table[1].ccktxbb_valuearray[4] = 0x1a;
 990         priv->cck_txbbgain_table[1].ccktxbb_valuearray[5] = 0x11;
 991         priv->cck_txbbgain_table[1].ccktxbb_valuearray[6] = 0x08;
 992         priv->cck_txbbgain_table[1].ccktxbb_valuearray[7] = 0x04;
 993
 994         priv->cck_txbbgain_table[2].ccktxbb_valuearray[0] = 0x30;
 995         priv->cck_txbbgain_table[2].ccktxbb_valuearray[1] = 0x2f;
 996         priv->cck_txbbgain_table[2].ccktxbb_valuearray[2] = 0x29;
 997         priv->cck_txbbgain_table[2].ccktxbb_valuearray[3] = 0x21;
 998         priv->cck_txbbgain_table[2].ccktxbb_valuearray[4] = 0x19;
 999         priv->cck_txbbgain_table[2].ccktxbb_valuearray[5] = 0x10;
1000         priv->cck_txbbgain_table[2].ccktxbb_valuearray[6] = 0x08;
1001         priv->cck_txbbgain_table[2].ccktxbb_valuearray[7] = 0x03;
1002
1003         priv->cck_txbbgain_table[3].ccktxbb_valuearray[0] = 0x2d;
1004         priv->cck_txbbgain_table[3].ccktxbb_valuearray[1] = 0x2d;
1005         priv->cck_txbbgain_table[3].ccktxbb_valuearray[2] = 0x27;
1006         priv->cck_txbbgain_table[3].ccktxbb_valuearray[3] = 0x1f;
1007         priv->cck_txbbgain_table[3].ccktxbb_valuearray[4] = 0x18;
1008         priv->cck_txbbgain_table[3].ccktxbb_valuearray[5] = 0x0f;
1009         priv->cck_txbbgain_table[3].ccktxbb_valuearray[6] = 0x08;
1010         priv->cck_txbbgain_table[3].ccktxbb_valuearray[7] = 0x03;
1011
1012         priv->cck_txbbgain_table[4].ccktxbb_valuearray[0] = 0x2b;
1013         priv->cck_txbbgain_table[4].ccktxbb_valuearray[1] = 0x2a;
1014         priv->cck_txbbgain_table[4].ccktxbb_valuearray[2] = 0x25;
1015         priv->cck_txbbgain_table[4].ccktxbb_valuearray[3] = 0x1e;
1016         priv->cck_txbbgain_table[4].ccktxbb_valuearray[4] = 0x16;
1017         priv->cck_txbbgain_table[4].ccktxbb_valuearray[5] = 0x0e;
1018         priv->cck_txbbgain_table[4].ccktxbb_valuearray[6] = 0x07;
1019         priv->cck_txbbgain_table[4].ccktxbb_valuearray[7] = 0x03;
1020
1021         priv->cck_txbbgain_table[5].ccktxbb_valuearray[0] = 0x28;
1022         priv->cck_txbbgain_table[5].ccktxbb_valuearray[1] = 0x28;
1023         priv->cck_txbbgain_table[5].ccktxbb_valuearray[2] = 0x22;
1024         priv->cck_txbbgain_table[5].ccktxbb_valuearray[3] = 0x1c;
1025         priv->cck_txbbgain_table[5].ccktxbb_valuearray[4] = 0x15;
1026         priv->cck_txbbgain_table[5].ccktxbb_valuearray[5] = 0x0d;
1027         priv->cck_txbbgain_table[5].ccktxbb_valuearray[6] = 0x07;
1028         priv->cck_txbbgain_table[5].ccktxbb_valuearray[7] = 0x03;
1029
1030         priv->cck_txbbgain_table[6].ccktxbb_valuearray[0] = 0x26;
1031         priv->cck_txbbgain_table[6].ccktxbb_valuearray[1] = 0x25;
1032         priv->cck_txbbgain_table[6].ccktxbb_valuearray[2] = 0x21;
1033         priv->cck_txbbgain_table[6].ccktxbb_valuearray[3] = 0x1b;
1034         priv->cck_txbbgain_table[6].ccktxbb_valuearray[4] = 0x14;
1035         priv->cck_txbbgain_table[6].ccktxbb_valuearray[5] = 0x0d;
1036         priv->cck_txbbgain_table[6].ccktxbb_valuearray[6] = 0x06;
1037         priv->cck_txbbgain_table[6].ccktxbb_valuearray[7] = 0x03;
1038
1039         priv->cck_txbbgain_table[7].ccktxbb_valuearray[0] = 0x24;
1040         priv->cck_txbbgain_table[7].ccktxbb_valuearray[1] = 0x23;
1041         priv->cck_txbbgain_table[7].ccktxbb_valuearray[2] = 0x1f;
1042         priv->cck_txbbgain_table[7].ccktxbb_valuearray[3] = 0x19;
1043         priv->cck_txbbgain_table[7].ccktxbb_valuearray[4] = 0x13;
1044         priv->cck_txbbgain_table[7].ccktxbb_valuearray[5] = 0x0c;
1045         priv->cck_txbbgain_table[7].ccktxbb_valuearray[6] = 0x06;
1046         priv->cck_txbbgain_table[7].ccktxbb_valuearray[7] = 0x03;
1047
1048         priv->cck_txbbgain_table[8].ccktxbb_valuearray[0] = 0x22;
1049         priv->cck_txbbgain_table[8].ccktxbb_valuearray[1] = 0x21;
1050         priv->cck_txbbgain_table[8].ccktxbb_valuearray[2] = 0x1d;
1051         priv->cck_txbbgain_table[8].ccktxbb_valuearray[3] = 0x18;
1052         priv->cck_txbbgain_table[8].ccktxbb_valuearray[4] = 0x11;
1053         priv->cck_txbbgain_table[8].ccktxbb_valuearray[5] = 0x0b;
1054         priv->cck_txbbgain_table[8].ccktxbb_valuearray[6] = 0x06;
1055         priv->cck_txbbgain_table[8].ccktxbb_valuearray[7] = 0x02;
1056
1057         priv->cck_txbbgain_table[9].ccktxbb_valuearray[0] = 0x20;
1058         priv->cck_txbbgain_table[9].ccktxbb_valuearray[1] = 0x20;
1059         priv->cck_txbbgain_table[9].ccktxbb_valuearray[2] = 0x1b;
1060         priv->cck_txbbgain_table[9].ccktxbb_valuearray[3] = 0x16;
1061         priv->cck_txbbgain_table[9].ccktxbb_valuearray[4] = 0x11;
1062         priv->cck_txbbgain_table[9].ccktxbb_valuearray[5] = 0x08;
1063         priv->cck_txbbgain_table[9].ccktxbb_valuearray[6] = 0x05;
1064         priv->cck_txbbgain_table[9].ccktxbb_valuearray[7] = 0x02;
1065
1066         priv->cck_txbbgain_table[10].ccktxbb_valuearray[0] = 0x1f;
1067         priv->cck_txbbgain_table[10].ccktxbb_valuearray[1] = 0x1e;
1068         priv->cck_txbbgain_table[10].ccktxbb_valuearray[2] = 0x1a;
1069         priv->cck_txbbgain_table[10].ccktxbb_valuearray[3] = 0x15;
1070         priv->cck_txbbgain_table[10].ccktxbb_valuearray[4] = 0x10;
1071         priv->cck_txbbgain_table[10].ccktxbb_valuearray[5] = 0x0a;
1072         priv->cck_txbbgain_table[10].ccktxbb_valuearray[6] = 0x05;
1073         priv->cck_txbbgain_table[10].ccktxbb_valuearray[7] = 0x02;
1074
1075         priv->cck_txbbgain_table[11].ccktxbb_valuearray[0] = 0x1d;
1076         priv->cck_txbbgain_table[11].ccktxbb_valuearray[1] = 0x1c;
1077         priv->cck_txbbgain_table[11].ccktxbb_valuearray[2] = 0x18;
1078         priv->cck_txbbgain_table[11].ccktxbb_valuearray[3] = 0x14;
1079         priv->cck_txbbgain_table[11].ccktxbb_valuearray[4] = 0x0f;
1080         priv->cck_txbbgain_table[11].ccktxbb_valuearray[5] = 0x0a;
1081         priv->cck_txbbgain_table[11].ccktxbb_valuearray[6] = 0x05;
1082         priv->cck_txbbgain_table[11].ccktxbb_valuearray[7] = 0x02;
1083
1084         priv->cck_txbbgain_table[12].ccktxbb_valuearray[0] = 0x1b;
1085         priv->cck_txbbgain_table[12].ccktxbb_valuearray[1] = 0x1a;
1086         priv->cck_txbbgain_table[12].ccktxbb_valuearray[2] = 0x17;
1087         priv->cck_txbbgain_table[12].ccktxbb_valuearray[3] = 0x13;
1088         priv->cck_txbbgain_table[12].ccktxbb_valuearray[4] = 0x0e;
1089         priv->cck_txbbgain_table[12].ccktxbb_valuearray[5] = 0x09;
1090         priv->cck_txbbgain_table[12].ccktxbb_valuearray[6] = 0x04;
1091         priv->cck_txbbgain_table[12].ccktxbb_valuearray[7] = 0x02;
1092
1093         priv->cck_txbbgain_table[13].ccktxbb_valuearray[0] = 0x1a;
1094         priv->cck_txbbgain_table[13].ccktxbb_valuearray[1] = 0x19;
1095         priv->cck_txbbgain_table[13].ccktxbb_valuearray[2] = 0x16;
1096         priv->cck_txbbgain_table[13].ccktxbb_valuearray[3] = 0x12;
1097         priv->cck_txbbgain_table[13].ccktxbb_valuearray[4] = 0x0d;
1098         priv->cck_txbbgain_table[13].ccktxbb_valuearray[5] = 0x09;
1099         priv->cck_txbbgain_table[13].ccktxbb_valuearray[6] = 0x04;
1100         priv->cck_txbbgain_table[13].ccktxbb_valuearray[7] = 0x02;
1101
1102         priv->cck_txbbgain_table[14].ccktxbb_valuearray[0] = 0x18;
1103         priv->cck_txbbgain_table[14].ccktxbb_valuearray[1] = 0x17;
1104         priv->cck_txbbgain_table[14].ccktxbb_valuearray[2] = 0x15;
1105         priv->cck_txbbgain_table[14].ccktxbb_valuearray[3] = 0x11;
1106         priv->cck_txbbgain_table[14].ccktxbb_valuearray[4] = 0x0c;
1107         priv->cck_txbbgain_table[14].ccktxbb_valuearray[5] = 0x08;
1108         priv->cck_txbbgain_table[14].ccktxbb_valuearray[6] = 0x04;
1109         priv->cck_txbbgain_table[14].ccktxbb_valuearray[7] = 0x02;
1110
1111         priv->cck_txbbgain_table[15].ccktxbb_valuearray[0] = 0x17;
1112         priv->cck_txbbgain_table[15].ccktxbb_valuearray[1] = 0x16;
1113         priv->cck_txbbgain_table[15].ccktxbb_valuearray[2] = 0x13;
1114         priv->cck_txbbgain_table[15].ccktxbb_valuearray[3] = 0x10;
1115         priv->cck_txbbgain_table[15].ccktxbb_valuearray[4] = 0x0c;
1116         priv->cck_txbbgain_table[15].ccktxbb_valuearray[5] = 0x08;
1117         priv->cck_txbbgain_table[15].ccktxbb_valuearray[6] = 0x04;
1118         priv->cck_txbbgain_table[15].ccktxbb_valuearray[7] = 0x02;
1119
1120         priv->cck_txbbgain_table[16].ccktxbb_valuearray[0] = 0x16;
1121         priv->cck_txbbgain_table[16].ccktxbb_valuearray[1] = 0x15;
1122         priv->cck_txbbgain_table[16].ccktxbb_valuearray[2] = 0x12;
1123         priv->cck_txbbgain_table[16].ccktxbb_valuearray[3] = 0x0f;
1124         priv->cck_txbbgain_table[16].ccktxbb_valuearray[4] = 0x0b;
1125         priv->cck_txbbgain_table[16].ccktxbb_valuearray[5] = 0x07;
1126         priv->cck_txbbgain_table[16].ccktxbb_valuearray[6] = 0x04;
1127         priv->cck_txbbgain_table[16].ccktxbb_valuearray[7] = 0x01;
1128
1129         priv->cck_txbbgain_table[17].ccktxbb_valuearray[0] = 0x14;
1130         priv->cck_txbbgain_table[17].ccktxbb_valuearray[1] = 0x14;
1131         priv->cck_txbbgain_table[17].ccktxbb_valuearray[2] = 0x11;
1132         priv->cck_txbbgain_table[17].ccktxbb_valuearray[3] = 0x0e;
1133         priv->cck_txbbgain_table[17].ccktxbb_valuearray[4] = 0x0b;
1134         priv->cck_txbbgain_table[17].ccktxbb_valuearray[5] = 0x07;
1135         priv->cck_txbbgain_table[17].ccktxbb_valuearray[6] = 0x03;
1136         priv->cck_txbbgain_table[17].ccktxbb_valuearray[7] = 0x02;
1137
1138         priv->cck_txbbgain_table[18].ccktxbb_valuearray[0] = 0x13;
1139         priv->cck_txbbgain_table[18].ccktxbb_valuearray[1] = 0x13;
1140         priv->cck_txbbgain_table[18].ccktxbb_valuearray[2] = 0x10;
1141         priv->cck_txbbgain_table[18].ccktxbb_valuearray[3] = 0x0d;
1142         priv->cck_txbbgain_table[18].ccktxbb_valuearray[4] = 0x0a;
1143         priv->cck_txbbgain_table[18].ccktxbb_valuearray[5] = 0x06;
1144         priv->cck_txbbgain_table[18].ccktxbb_valuearray[6] = 0x03;
1145         priv->cck_txbbgain_table[18].ccktxbb_valuearray[7] = 0x01;
1146
1147         priv->cck_txbbgain_table[19].ccktxbb_valuearray[0] = 0x12;
1148         priv->cck_txbbgain_table[19].ccktxbb_valuearray[1] = 0x12;
1149         priv->cck_txbbgain_table[19].ccktxbb_valuearray[2] = 0x0f;
1150         priv->cck_txbbgain_table[19].ccktxbb_valuearray[3] = 0x0c;
1151         priv->cck_txbbgain_table[19].ccktxbb_valuearray[4] = 0x09;
1152         priv->cck_txbbgain_table[19].ccktxbb_valuearray[5] = 0x06;
1153         priv->cck_txbbgain_table[19].ccktxbb_valuearray[6] = 0x03;
1154         priv->cck_txbbgain_table[19].ccktxbb_valuearray[7] = 0x01;
1155
1156         priv->cck_txbbgain_table[20].ccktxbb_valuearray[0] = 0x11;
1157         priv->cck_txbbgain_table[20].ccktxbb_valuearray[1] = 0x11;
1158         priv->cck_txbbgain_table[20].ccktxbb_valuearray[2] = 0x0f;
1159         priv->cck_txbbgain_table[20].ccktxbb_valuearray[3] = 0x0c;
1160         priv->cck_txbbgain_table[20].ccktxbb_valuearray[4] = 0x09;
1161         priv->cck_txbbgain_table[20].ccktxbb_valuearray[5] = 0x06;
1162         priv->cck_txbbgain_table[20].ccktxbb_valuearray[6] = 0x03;
1163         priv->cck_txbbgain_table[20].ccktxbb_valuearray[7] = 0x01;
1164
1165         priv->cck_txbbgain_table[21].ccktxbb_valuearray[0] = 0x10;
1166         priv->cck_txbbgain_table[21].ccktxbb_valuearray[1] = 0x10;
1167         priv->cck_txbbgain_table[21].ccktxbb_valuearray[2] = 0x0e;
1168         priv->cck_txbbgain_table[21].ccktxbb_valuearray[3] = 0x0b;
1169         priv->cck_txbbgain_table[21].ccktxbb_valuearray[4] = 0x08;
1170         priv->cck_txbbgain_table[21].ccktxbb_valuearray[5] = 0x05;
1171         priv->cck_txbbgain_table[21].ccktxbb_valuearray[6] = 0x03;
1172         priv->cck_txbbgain_table[21].ccktxbb_valuearray[7] = 0x01;
1173
1174         priv->cck_txbbgain_table[22].ccktxbb_valuearray[0] = 0x0f;
1175         priv->cck_txbbgain_table[22].ccktxbb_valuearray[1] = 0x0f;
1176         priv->cck_txbbgain_table[22].ccktxbb_valuearray[2] = 0x0d;
1177         priv->cck_txbbgain_table[22].ccktxbb_valuearray[3] = 0x0b;
1178         priv->cck_txbbgain_table[22].ccktxbb_valuearray[4] = 0x08;
1179         priv->cck_txbbgain_table[22].ccktxbb_valuearray[5] = 0x05;
1180         priv->cck_txbbgain_table[22].ccktxbb_valuearray[6] = 0x03;
1181         priv->cck_txbbgain_table[22].ccktxbb_valuearray[7] = 0x01;
1182
1183         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[0] = 0x36;
1184         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[1] = 0x35;
1185         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[2] = 0x2e;
1186         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[3] = 0x1b;
1187         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[4] = 0x00;
1188         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[5] = 0x00;
1189         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[6] = 0x00;
1190         priv->cck_txbbgain_ch14_table[0].ccktxbb_valuearray[7] = 0x00;
1191
1192         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[0] = 0x33;
1193         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[1] = 0x32;
1194         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[2] = 0x2b;
1195         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[3] = 0x19;
1196         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[4] = 0x00;
1197         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[5] = 0x00;
1198         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[6] = 0x00;
1199         priv->cck_txbbgain_ch14_table[1].ccktxbb_valuearray[7] = 0x00;
1200
1201         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[0] = 0x30;
1202         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[1] = 0x2f;
1203         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[2] = 0x29;
1204         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[3] = 0x18;
1205         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[4] = 0x00;
1206         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[5] = 0x00;
1207         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[6] = 0x00;
1208         priv->cck_txbbgain_ch14_table[2].ccktxbb_valuearray[7] = 0x00;
1209
1210         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[0] = 0x2d;
1211         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[1] = 0x2d;
1212         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[2] = 0x27;
1213         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[3] = 0x17;
1214         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[4] = 0x00;
1215         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[5] = 0x00;
1216         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[6] = 0x00;
1217         priv->cck_txbbgain_ch14_table[3].ccktxbb_valuearray[7] = 0x00;
1218
1219         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[0] = 0x2b;
1220         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[1] = 0x2a;
1221         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[2] = 0x25;
1222         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[3] = 0x15;
1223         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[4] = 0x00;
1224         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[5] = 0x00;
1225         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[6] = 0x00;
1226         priv->cck_txbbgain_ch14_table[4].ccktxbb_valuearray[7] = 0x00;
1227
1228         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[0] = 0x28;
1229         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[1] = 0x28;
1230         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[2] = 0x22;
1231         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[3] = 0x14;
1232         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[4] = 0x00;
1233         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[5] = 0x00;
1234         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[6] = 0x00;
1235         priv->cck_txbbgain_ch14_table[5].ccktxbb_valuearray[7] = 0x00;
1236
1237         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[0] = 0x26;
1238         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[1] = 0x25;
1239         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[2] = 0x21;
1240         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[3] = 0x13;
1241         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[4] = 0x00;
1242         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[5] = 0x00;
1243         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[6] = 0x00;
1244         priv->cck_txbbgain_ch14_table[6].ccktxbb_valuearray[7] = 0x00;
1245
1246         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[0] = 0x24;
1247         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[1] = 0x23;
1248         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[2] = 0x1f;
1249         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[3] = 0x12;
1250         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[4] = 0x00;
1251         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[5] = 0x00;
1252         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[6] = 0x00;
1253         priv->cck_txbbgain_ch14_table[7].ccktxbb_valuearray[7] = 0x00;
1254
1255         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[0] = 0x22;
1256         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[1] = 0x21;
1257         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[2] = 0x1d;
1258         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[3] = 0x11;
1259         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[4] = 0x00;
1260         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[5] = 0x00;
1261         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[6] = 0x00;
1262         priv->cck_txbbgain_ch14_table[8].ccktxbb_valuearray[7] = 0x00;
1263
1264         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[0] = 0x20;
1265         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[1] = 0x20;
1266         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[2] = 0x1b;
1267         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[3] = 0x10;
1268         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[4] = 0x00;
1269         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[5] = 0x00;
1270         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[6] = 0x00;
1271         priv->cck_txbbgain_ch14_table[9].ccktxbb_valuearray[7] = 0x00;
1272
1273         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[0] = 0x1f;
1274         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[1] = 0x1e;
1275         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[2] = 0x1a;
1276         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[3] = 0x0f;
1277         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[4] = 0x00;
1278         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[5] = 0x00;
1279         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[6] = 0x00;
1280         priv->cck_txbbgain_ch14_table[10].ccktxbb_valuearray[7] = 0x00;
1281
1282         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[0] = 0x1d;
1283         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[1] = 0x1c;
1284         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[2] = 0x18;
1285         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[3] = 0x0e;
1286         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[4] = 0x00;
1287         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[5] = 0x00;
1288         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[6] = 0x00;
1289         priv->cck_txbbgain_ch14_table[11].ccktxbb_valuearray[7] = 0x00;
1290
1291         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[0] = 0x1b;
1292         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[1] = 0x1a;
1293         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[2] = 0x17;
1294         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[3] = 0x0e;
1295         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[4] = 0x00;
1296         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[5] = 0x00;
1297         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[6] = 0x00;
1298         priv->cck_txbbgain_ch14_table[12].ccktxbb_valuearray[7] = 0x00;
1299
1300         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[0] = 0x1a;
1301         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[1] = 0x19;
1302         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[2] = 0x16;
1303         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[3] = 0x0d;
1304         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[4] = 0x00;
1305         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[5] = 0x00;
1306         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[6] = 0x00;
1307         priv->cck_txbbgain_ch14_table[13].ccktxbb_valuearray[7] = 0x00;
1308
1309         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[0] = 0x18;
1310         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[1] = 0x17;
1311         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[2] = 0x15;
1312         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[3] = 0x0c;
1313         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[4] = 0x00;
1314         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[5] = 0x00;
1315         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[6] = 0x00;
1316         priv->cck_txbbgain_ch14_table[14].ccktxbb_valuearray[7] = 0x00;
1317
1318         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[0] = 0x17;
1319         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[1] = 0x16;
1320         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[2] = 0x13;
1321         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[3] = 0x0b;
1322         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[4] = 0x00;
1323         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[5] = 0x00;
1324         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[6] = 0x00;
1325         priv->cck_txbbgain_ch14_table[15].ccktxbb_valuearray[7] = 0x00;
1326
1327         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[0] = 0x16;
1328         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[1] = 0x15;
1329         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[2] = 0x12;
1330         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[3] = 0x0b;
1331         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[4] = 0x00;
1332         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[5] = 0x00;
1333         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[6] = 0x00;
1334         priv->cck_txbbgain_ch14_table[16].ccktxbb_valuearray[7] = 0x00;
1335
1336         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[0] = 0x14;
1337         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[1] = 0x14;
1338         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[2] = 0x11;
1339         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[3] = 0x0a;
1340         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[4] = 0x00;
1341         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[5] = 0x00;
1342         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[6] = 0x00;
1343         priv->cck_txbbgain_ch14_table[17].ccktxbb_valuearray[7] = 0x00;
1344
1345         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[0] = 0x13;
1346         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[1] = 0x13;
1347         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[2] = 0x10;
1348         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[3] = 0x0a;
1349         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[4] = 0x00;
1350         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[5] = 0x00;
1351         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[6] = 0x00;
1352         priv->cck_txbbgain_ch14_table[18].ccktxbb_valuearray[7] = 0x00;
1353
1354         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[0] = 0x12;
1355         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[1] = 0x12;
1356         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[2] = 0x0f;
1357         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[3] = 0x09;
1358         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[4] = 0x00;
1359         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[5] = 0x00;
1360         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[6] = 0x00;
1361         priv->cck_txbbgain_ch14_table[19].ccktxbb_valuearray[7] = 0x00;
1362
1363         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[0] = 0x11;
1364         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[1] = 0x11;
1365         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[2] = 0x0f;
1366         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[3] = 0x09;
1367         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[4] = 0x00;
1368         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[5] = 0x00;
1369         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[6] = 0x00;
1370         priv->cck_txbbgain_ch14_table[20].ccktxbb_valuearray[7] = 0x00;
1371
1372         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[0] = 0x10;
1373         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[1] = 0x10;
1374         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[2] = 0x0e;
1375         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[3] = 0x08;
1376         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[4] = 0x00;
1377         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[5] = 0x00;
1378         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[6] = 0x00;
1379         priv->cck_txbbgain_ch14_table[21].ccktxbb_valuearray[7] = 0x00;
1380
1381         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[0] = 0x0f;
1382         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[1] = 0x0f;
1383         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[2] = 0x0d;
1384         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[3] = 0x08;
1385         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[4] = 0x00;
1386         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[5] = 0x00;
1387         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[6] = 0x00;
1388         priv->cck_txbbgain_ch14_table[22].ccktxbb_valuearray[7] = 0x00;
1389
1390         priv->btxpower_tracking = true;
1391         priv->txpower_count       = 0;
1392         priv->btxpower_trackingInit = false;
1393
1394 }
1395
1396 static void dm_InitializeTXPowerTracking_ThermalMeter(struct net_device *dev)
1397 {
1398         struct r8192_priv *priv = rtllib_priv(dev);
1399
1400
1401         if (priv->rtllib->FwRWRF)
1402                 priv->btxpower_tracking = true;
1403         else
1404                 priv->btxpower_tracking = false;
1405         priv->txpower_count       = 0;
1406         priv->btxpower_trackingInit = false;
1407         RT_TRACE(COMP_POWER_TRACKING, "pMgntInfo->bTXPowerTracking = %d\n", priv->btxpower_tracking);
1408 }
1409
1410 void dm_initialize_txpower_tracking(struct net_device *dev)
1411 {
1412         struct r8192_priv *priv = rtllib_priv(dev);
1413         if (priv->IC_Cut >= IC_VersionCut_D)
1414                 dm_InitializeTXPowerTracking_TSSI(dev);
1415         else
1416                 dm_InitializeTXPowerTracking_ThermalMeter(dev);
1417 }
1418
1419 static void dm_CheckTXPowerTracking_TSSI(struct net_device *dev)
1420 {
1421         struct r8192_priv *priv = rtllib_priv(dev);
1422         static u32 tx_power_track_counter = 0;
1423         RT_TRACE(COMP_POWER_TRACKING,"%s()\n",__func__);
1424         if (read_nic_byte(dev, 0x11e) ==1)
1425                 return;
1426         if (!priv->btxpower_tracking)
1427                 return;
1428         tx_power_track_counter++;
1429
1430
1431          if (tx_power_track_counter >= 180)
1432                 {
1433                 queue_delayed_work_rsl(priv->priv_wq,&priv->txpower_tracking_wq,0);
1434                 tx_power_track_counter =0;
1435                 }
1436
1437 }
1438 static void dm_CheckTXPowerTracking_ThermalMeter(struct net_device *dev)
1439 {
1440         struct r8192_priv *priv = rtllib_priv(dev);
1441         static u8       TM_Trigger=0;
1442         u8              TxPowerCheckCnt = 0;
1443
1444         if (IS_HARDWARE_TYPE_8192SE(dev))
1445                 TxPowerCheckCnt = 5;
1446         else
1447                 TxPowerCheckCnt = 2;
1448         if (!priv->btxpower_tracking){
1449             return;
1450         } else {
1451             if (priv->txpower_count  <= TxPowerCheckCnt) {
1452                         priv->txpower_count++;
1453                         return;
1454                 }
1455         }
1456
1457         if (!TM_Trigger)
1458         {
1459                 {
1460                 rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4d);
1461                 rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4f);
1462                 rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4d);
1463                 rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4f);
1464                 }
1465                 TM_Trigger = 1;
1466                 return;
1467         } else {
1468             printk("===============>Schedule TxPowerTrackingWorkItem\n");
1469
1470                 queue_delayed_work_rsl(priv->priv_wq,&priv->txpower_tracking_wq,0);
1471                 TM_Trigger = 0;
1472                 }
1473
1474         }
1475
1476 static void dm_check_txpower_tracking(struct net_device *dev)
1477 {
1478         struct r8192_priv *priv = rtllib_priv(dev);
1479
1480         if (priv->IC_Cut >= IC_VersionCut_D)
1481                 dm_CheckTXPowerTracking_TSSI(dev);
1482         else
1483                 dm_CheckTXPowerTracking_ThermalMeter(dev);
1484 }
1485
1486 static void dm_CCKTxPowerAdjust_TSSI(struct net_device *dev, bool  bInCH14)
1487 {
1488         u32 TempVal;
1489         struct r8192_priv *priv = rtllib_priv(dev);
1490         TempVal = 0;
1491         if (!bInCH14){
1492                 TempVal =       (u32)(priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[0] +
1493                                         (priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[1]<<8)) ;
1494
1495                 rtl8192_setBBreg(dev, rCCK0_TxFilter1,bMaskHWord, TempVal);
1496                 TempVal = 0;
1497                 TempVal =       (u32)(priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[2] +
1498                                         (priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[3]<<8) +
1499                                         (priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[4]<<16 )+
1500                                         (priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[5]<<24));
1501                 rtl8192_setBBreg(dev, rCCK0_TxFilter2,bMaskDWord, TempVal);
1502                 TempVal = 0;
1503                 TempVal =       (u32)(priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[6] +
1504                                         (priv->cck_txbbgain_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[7]<<8)) ;
1505
1506                 rtl8192_setBBreg(dev, rCCK0_DebugPort,bMaskLWord, TempVal);
1507         }
1508         else
1509         {
1510                 TempVal =       (u32)(priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[0] +
1511                                         (priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[1]<<8)) ;
1512
1513                 rtl8192_setBBreg(dev, rCCK0_TxFilter1,bMaskHWord, TempVal);
1514                 TempVal = 0;
1515                 TempVal =       (u32)(priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[2] +
1516                                         (priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[3]<<8) +
1517                                         (priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[4]<<16 )+
1518                                         (priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[5]<<24));
1519                 rtl8192_setBBreg(dev, rCCK0_TxFilter2,bMaskDWord, TempVal);
1520                 TempVal = 0;
1521                 TempVal =       (u32)(priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[6] +
1522                                         (priv->cck_txbbgain_ch14_table[(u8)(priv->CCKPresentAttentuation)].ccktxbb_valuearray[7]<<8)) ;
1523
1524                 rtl8192_setBBreg(dev, rCCK0_DebugPort,bMaskLWord, TempVal);
1525         }
1526
1527
1528 }
1529
1530 static void dm_CCKTxPowerAdjust_ThermalMeter(struct net_device *dev,    bool  bInCH14)
1531 {
1532         u32 TempVal;
1533         struct r8192_priv *priv = rtllib_priv(dev);
1534
1535         TempVal = 0;
1536         if (!bInCH14)
1537         {
1538                 TempVal =       CCKSwingTable_Ch1_Ch13[priv->CCK_index][0] +
1539                                         (CCKSwingTable_Ch1_Ch13[priv->CCK_index][1]<<8) ;
1540                 rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal);
1541                 RT_TRACE(COMP_POWER_TRACKING, "CCK not chnl 14, reg 0x%x = 0x%x\n",
1542                         rCCK0_TxFilter1, TempVal);
1543                 TempVal = 0;
1544                 TempVal =       CCKSwingTable_Ch1_Ch13[priv->CCK_index][2] +
1545                                         (CCKSwingTable_Ch1_Ch13[priv->CCK_index][3]<<8) +
1546                                         (CCKSwingTable_Ch1_Ch13[priv->CCK_index][4]<<16 )+
1547                                         (CCKSwingTable_Ch1_Ch13[priv->CCK_index][5]<<24);
1548                 rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal);
1549                 RT_TRACE(COMP_POWER_TRACKING, "CCK not chnl 14, reg 0x%x = 0x%x\n",
1550                         rCCK0_TxFilter2, TempVal);
1551                 TempVal = 0;
1552                 TempVal =       CCKSwingTable_Ch1_Ch13[priv->CCK_index][6] +
1553                                         (CCKSwingTable_Ch1_Ch13[priv->CCK_index][7]<<8) ;
1554
1555                 rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal);
1556                 RT_TRACE(COMP_POWER_TRACKING, "CCK not chnl 14, reg 0x%x = 0x%x\n",
1557                         rCCK0_DebugPort, TempVal);
1558         }
1559         else
1560         {
1561                 TempVal =       CCKSwingTable_Ch14[priv->CCK_index][0] +
1562                                         (CCKSwingTable_Ch14[priv->CCK_index][1]<<8) ;
1563
1564                 rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal);
1565                 RT_TRACE(COMP_POWER_TRACKING, "CCK chnl 14, reg 0x%x = 0x%x\n",
1566                         rCCK0_TxFilter1, TempVal);
1567                 TempVal = 0;
1568                 TempVal =       CCKSwingTable_Ch14[priv->CCK_index][2] +
1569                                         (CCKSwingTable_Ch14[priv->CCK_index][3]<<8) +
1570                                         (CCKSwingTable_Ch14[priv->CCK_index][4]<<16 )+
1571                                         (CCKSwingTable_Ch14[priv->CCK_index][5]<<24);
1572                 rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal);
1573                 RT_TRACE(COMP_POWER_TRACKING, "CCK chnl 14, reg 0x%x = 0x%x\n",
1574                         rCCK0_TxFilter2, TempVal);
1575                 TempVal = 0;
1576                 TempVal =       CCKSwingTable_Ch14[priv->CCK_index][6] +
1577                                         (CCKSwingTable_Ch14[priv->CCK_index][7]<<8) ;
1578
1579                 rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal);
1580                 RT_TRACE(COMP_POWER_TRACKING,"CCK chnl 14, reg 0x%x = 0x%x\n",
1581                         rCCK0_DebugPort, TempVal);
1582         }
1583         }
1584
1585 extern void dm_cck_txpower_adjust(
1586         struct net_device *dev,
1587         bool  binch14
1588 )
1589 {
1590         struct r8192_priv *priv = rtllib_priv(dev);
1591         if (priv->IC_Cut >= IC_VersionCut_D)
1592                 dm_CCKTxPowerAdjust_TSSI(dev, binch14);
1593         else
1594                 dm_CCKTxPowerAdjust_ThermalMeter(dev, binch14);
1595 }
1596
1597 static void dm_txpower_reset_recovery(
1598         struct net_device *dev
1599 )
1600 {
1601         struct r8192_priv *priv = rtllib_priv(dev);
1602
1603         RT_TRACE(COMP_POWER_TRACKING, "Start Reset Recovery ==>\n");
1604         rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfa_txpowertrackingindex].txbbgain_value);
1605         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in 0xc80 is %08x\n",priv->txbbgain_table[priv->rfa_txpowertrackingindex].txbbgain_value);
1606         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in RFA_txPowerTrackingIndex is %x\n",priv->rfa_txpowertrackingindex);
1607         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery : RF A I/Q Amplify Gain is %ld\n",priv->txbbgain_table[priv->rfa_txpowertrackingindex].txbb_iq_amplifygain);
1608         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: CCK Attenuation is %d dB\n",priv->CCKPresentAttentuation);
1609         dm_cck_txpower_adjust(dev,priv->bcck_in_ch14);
1610
1611         rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfc_txpowertrackingindex].txbbgain_value);
1612         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in 0xc90 is %08x\n",priv->txbbgain_table[priv->rfc_txpowertrackingindex].txbbgain_value);
1613         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in RFC_txPowerTrackingIndex is %x\n",priv->rfc_txpowertrackingindex);
1614         RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery : RF C I/Q Amplify Gain is %ld\n",priv->txbbgain_table[priv->rfc_txpowertrackingindex].txbb_iq_amplifygain);
1615
1616 }
1617
1618 extern void dm_restore_dynamic_mechanism_state(struct net_device *dev)
1619 {
1620         struct r8192_priv *priv = rtllib_priv(dev);
1621         u32     reg_ratr = priv->rate_adaptive.last_ratr;
1622
1623         if (IS_NIC_DOWN(priv)){
1624                 RT_TRACE(COMP_RATE, "<---- dm_restore_dynamic_mechanism_state(): driver is going to unload\n");
1625                 return;
1626         }
1627
1628         if (priv->rate_adaptive.rate_adaptive_disabled)
1629                 return;
1630         if ( !(priv->rtllib->mode==WIRELESS_MODE_N_24G ||
1631                  priv->rtllib->mode==WIRELESS_MODE_N_5G))
1632                  return;
1633         {
1634                         u32 ratr_value;
1635                         ratr_value = reg_ratr;
1636                         if (priv->rf_type == RF_1T2R)
1637                         {
1638                                 ratr_value &=~ (RATE_ALL_OFDM_2SS);
1639                         }
1640                         write_nic_dword(dev, RATR0, ratr_value);
1641                         write_nic_byte(dev, UFWP, 1);
1642         }
1643         if (priv->btxpower_trackingInit && priv->btxpower_tracking){
1644                 dm_txpower_reset_recovery(dev);
1645         }
1646
1647         dm_bb_initialgain_restore(dev);
1648
1649 }
1650
1651 static void dm_bb_initialgain_restore(struct net_device *dev)
1652 {
1653         struct r8192_priv *priv = rtllib_priv(dev);
1654         u32 bit_mask = 0x7f;
1655
1656         if (dm_digtable.dig_algorithm == DIG_ALGO_BY_RSSI)
1657                 return;
1658
1659         rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8);
1660         rtl8192_setBBreg(dev, rOFDM0_XAAGCCore1, bit_mask, (u32)priv->initgain_backup.xaagccore1);
1661         rtl8192_setBBreg(dev, rOFDM0_XBAGCCore1, bit_mask, (u32)priv->initgain_backup.xbagccore1);
1662         rtl8192_setBBreg(dev, rOFDM0_XCAGCCore1, bit_mask, (u32)priv->initgain_backup.xcagccore1);
1663         rtl8192_setBBreg(dev, rOFDM0_XDAGCCore1, bit_mask, (u32)priv->initgain_backup.xdagccore1);
1664         bit_mask  = bMaskByte2;
1665         rtl8192_setBBreg(dev, rCCK0_CCA, bit_mask, (u32)priv->initgain_backup.cca);
1666
1667         RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xc50 is %x\n",priv->initgain_backup.xaagccore1);
1668         RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xc58 is %x\n",priv->initgain_backup.xbagccore1);
1669         RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xc60 is %x\n",priv->initgain_backup.xcagccore1);
1670         RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xc68 is %x\n",priv->initgain_backup.xdagccore1);
1671         RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xa0a is %x\n",priv->initgain_backup.cca);
1672         rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1);
1673
1674 }
1675
1676
1677 extern void dm_backup_dynamic_mechanism_state(struct net_device *dev)
1678 {
1679         struct r8192_priv *priv = rtllib_priv(dev);
1680
1681         priv->bswitch_fsync  = false;
1682         priv->bfsync_processing = false;
1683         dm_bb_initialgain_backup(dev);
1684
1685 }
1686
1687
1688 static void dm_bb_initialgain_backup(struct net_device *dev)
1689 {
1690         struct r8192_priv *priv = rtllib_priv(dev);
1691         u32 bit_mask = bMaskByte0;
1692
1693         if (dm_digtable.dig_algorithm == DIG_ALGO_BY_RSSI)
1694                 return;
1695
1696         rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8);
1697         priv->initgain_backup.xaagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XAAGCCore1, bit_mask);
1698         priv->initgain_backup.xbagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XBAGCCore1, bit_mask);
1699         priv->initgain_backup.xcagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XCAGCCore1, bit_mask);
1700         priv->initgain_backup.xdagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XDAGCCore1, bit_mask);
1701         bit_mask  = bMaskByte2;
1702         priv->initgain_backup.cca = (u8)rtl8192_QueryBBReg(dev, rCCK0_CCA, bit_mask);
1703
1704         RT_TRACE(COMP_DIG, "BBInitialGainBackup 0xc50 is %x\n",priv->initgain_backup.xaagccore1);
1705         RT_TRACE(COMP_DIG, "BBInitialGainBackup 0xc58 is %x\n",priv->initgain_backup.xbagccore1);
1706         RT_TRACE(COMP_DIG, "BBInitialGainBackup 0xc60 is %x\n",priv->initgain_backup.xcagccore1);
1707         RT_TRACE(COMP_DIG, "BBInitialGainBackup 0xc68 is %x\n",priv->initgain_backup.xdagccore1);
1708         RT_TRACE(COMP_DIG, "BBInitialGainBackup 0xa0a is %x\n",priv->initgain_backup.cca);
1709
1710 }
1711
1712 extern void dm_change_dynamic_initgain_thresh(struct net_device *dev,
1713                                                                 u32             dm_type,
1714                                                                 u32             dm_value)
1715 {
1716         if (dm_type == DIG_TYPE_THRESH_HIGH)
1717         {
1718                 dm_digtable.rssi_high_thresh = dm_value;
1719         }
1720         else if (dm_type == DIG_TYPE_THRESH_LOW)
1721         {
1722                 dm_digtable.rssi_low_thresh = dm_value;
1723         }
1724         else if (dm_type == DIG_TYPE_THRESH_HIGHPWR_HIGH)
1725         {
1726                 dm_digtable.rssi_high_power_highthresh = dm_value;
1727         }
1728         else if (dm_type == DIG_TYPE_THRESH_HIGHPWR_HIGH)
1729         {
1730                 dm_digtable.rssi_high_power_highthresh = dm_value;
1731         }
1732         else if (dm_type == DIG_TYPE_ENABLE)
1733         {
1734                 dm_digtable.dig_state           = DM_STA_DIG_MAX;
1735                 dm_digtable.dig_enable_flag     = true;
1736         }
1737         else if (dm_type == DIG_TYPE_DISABLE)
1738         {
1739                 dm_digtable.dig_state           = DM_STA_DIG_MAX;
1740                 dm_digtable.dig_enable_flag     = false;
1741         }
1742         else if (dm_type == DIG_TYPE_DBG_MODE)
1743         {
1744                 if (dm_value >= DM_DBG_MAX)
1745                         dm_value = DM_DBG_OFF;
1746                 dm_digtable.dbg_mode            = (u8)dm_value;
1747         }
1748         else if (dm_type == DIG_TYPE_RSSI)
1749         {
1750                 if (dm_value > 100)
1751                         dm_value = 30;
1752                 dm_digtable.rssi_val                    = (long)dm_value;
1753         }
1754         else if (dm_type == DIG_TYPE_ALGORITHM)
1755         {
1756                 if (dm_value >= DIG_ALGO_MAX)
1757                         dm_value = DIG_ALGO_BY_FALSE_ALARM;
1758                 if (dm_digtable.dig_algorithm != (u8)dm_value)
1759                         dm_digtable.dig_algorithm_switch = 1;
1760                 dm_digtable.dig_algorithm       = (u8)dm_value;
1761         }
1762         else if (dm_type == DIG_TYPE_BACKOFF)
1763         {
1764                 if (dm_value > 30)
1765                         dm_value = 30;
1766                 dm_digtable.backoff_val         = (u8)dm_value;
1767         }
1768         else if (dm_type == DIG_TYPE_RX_GAIN_MIN)
1769         {
1770                 if (dm_value == 0)
1771                         dm_value = 0x1;
1772                 dm_digtable.rx_gain_range_min = (u8)dm_value;
1773         }
1774         else if (dm_type == DIG_TYPE_RX_GAIN_MAX)
1775         {
1776                 if (dm_value > 0x50)
1777                         dm_value = 0x50;
1778                 dm_digtable.rx_gain_range_max = (u8)dm_value;
1779         }
1780 }
1781 extern  void
1782 dm_change_fsync_setting(
1783         struct net_device *dev,
1784         s32             DM_Type,
1785         s32             DM_Value)
1786 {
1787         struct r8192_priv *priv = rtllib_priv(dev);
1788
1789         if (DM_Type == 0)
1790         {
1791                 if (DM_Value > 1)
1792                         DM_Value = 1;
1793                 priv->framesyncMonitor = (u8)DM_Value;
1794         }
1795 }
1796
1797 extern void
1798 dm_change_rxpath_selection_setting(
1799         struct net_device *dev,
1800         s32             DM_Type,
1801         s32             DM_Value)
1802 {
1803         struct r8192_priv *priv = rtllib_priv(dev);
1804         struct rate_adaptive *pRA = (struct rate_adaptive *)&(priv->rate_adaptive);
1805
1806
1807         if (DM_Type == 0)
1808         {
1809                 if (DM_Value > 1)
1810                         DM_Value = 1;
1811                 DM_RxPathSelTable.Enable = (u8)DM_Value;
1812         }
1813         else if (DM_Type == 1)
1814         {
1815                 if (DM_Value > 1)
1816                         DM_Value = 1;
1817                 DM_RxPathSelTable.DbgMode = (u8)DM_Value;
1818         }
1819         else if (DM_Type == 2)
1820         {
1821                 if (DM_Value > 40)
1822                         DM_Value = 40;
1823                 DM_RxPathSelTable.SS_TH_low = (u8)DM_Value;
1824         }
1825         else if (DM_Type == 3)
1826         {
1827                 if (DM_Value > 25)
1828                         DM_Value = 25;
1829                 DM_RxPathSelTable.diff_TH = (u8)DM_Value;
1830         }
1831         else if (DM_Type == 4)
1832         {
1833                 if (DM_Value >= CCK_Rx_Version_MAX)
1834                         DM_Value = CCK_Rx_Version_1;
1835                 DM_RxPathSelTable.cck_method= (u8)DM_Value;
1836         }
1837         else if (DM_Type == 10)
1838         {
1839                 if (DM_Value > 100)
1840                         DM_Value = 50;
1841                 DM_RxPathSelTable.rf_rssi[0] = (u8)DM_Value;
1842         }
1843         else if (DM_Type == 11)
1844         {
1845                 if (DM_Value > 100)
1846                         DM_Value = 50;
1847                 DM_RxPathSelTable.rf_rssi[1] = (u8)DM_Value;
1848         }
1849         else if (DM_Type == 12)
1850         {
1851                 if (DM_Value > 100)
1852                         DM_Value = 50;
1853                 DM_RxPathSelTable.rf_rssi[2] = (u8)DM_Value;
1854         }
1855         else if (DM_Type == 13)
1856         {
1857                 if (DM_Value > 100)
1858                         DM_Value = 50;
1859                 DM_RxPathSelTable.rf_rssi[3] = (u8)DM_Value;
1860         }
1861         else if (DM_Type == 20)
1862         {
1863                 if (DM_Value > 1)
1864                         DM_Value = 1;
1865                 pRA->ping_rssi_enable = (u8)DM_Value;
1866         }
1867         else if (DM_Type == 21)
1868         {
1869                 if (DM_Value > 30)
1870                         DM_Value = 30;
1871                 pRA->ping_rssi_thresh_for_ra = DM_Value;
1872         }
1873 }
1874
1875 static void dm_dig_init(struct net_device *dev)
1876 {
1877         struct r8192_priv *priv = rtllib_priv(dev);
1878         dm_digtable.dig_enable_flag     = true;
1879         dm_digtable.Backoff_Enable_Flag = true;
1880
1881         dm_digtable.dig_algorithm = DIG_ALGO_BY_RSSI;
1882
1883         dm_digtable.Dig_TwoPort_Algorithm = DIG_TWO_PORT_ALGO_RSSI;
1884         dm_digtable.Dig_Ext_Port_Stage = DIG_EXT_PORT_STAGE_MAX;
1885         dm_digtable.dbg_mode = DM_DBG_OFF;
1886         dm_digtable.dig_algorithm_switch = 0;
1887
1888         dm_digtable.dig_state           = DM_STA_DIG_MAX;
1889         dm_digtable.dig_highpwr_state   = DM_STA_DIG_MAX;
1890         dm_digtable.CurSTAConnectState = dm_digtable.PreSTAConnectState = DIG_STA_DISCONNECT;
1891         dm_digtable.CurAPConnectState = dm_digtable.PreAPConnectState = DIG_AP_DISCONNECT;
1892         dm_digtable.initialgain_lowerbound_state = false;
1893
1894         dm_digtable.rssi_low_thresh     = DM_DIG_THRESH_LOW;
1895         dm_digtable.rssi_high_thresh    = DM_DIG_THRESH_HIGH;
1896
1897         dm_digtable.FALowThresh = DM_FALSEALARM_THRESH_LOW;
1898         dm_digtable.FAHighThresh        = DM_FALSEALARM_THRESH_HIGH;
1899
1900         dm_digtable.rssi_high_power_lowthresh = DM_DIG_HIGH_PWR_THRESH_LOW;
1901         dm_digtable.rssi_high_power_highthresh = DM_DIG_HIGH_PWR_THRESH_HIGH;
1902
1903         dm_digtable.rssi_val = 50;
1904         dm_digtable.backoff_val = DM_DIG_BACKOFF;
1905         dm_digtable.rx_gain_range_max = DM_DIG_MAX;
1906         if (priv->CustomerID == RT_CID_819x_Netcore)
1907                 dm_digtable.rx_gain_range_min = DM_DIG_MIN_Netcore;
1908         else
1909                 dm_digtable.rx_gain_range_min = DM_DIG_MIN;
1910
1911         dm_digtable.BackoffVal_range_max = DM_DIG_BACKOFF_MAX;
1912         dm_digtable.BackoffVal_range_min = DM_DIG_BACKOFF_MIN;
1913 }
1914
1915 void dm_FalseAlarmCounterStatistics(struct net_device *dev)
1916 {
1917         struct r8192_priv *priv = rtllib_priv(dev);
1918         u32 ret_value;
1919         struct false_alarm_stats *FalseAlmCnt = &(priv->FalseAlmCnt);
1920
1921         ret_value = rtl8192_QueryBBReg(dev, rOFDM_PHYCounter1, bMaskDWord);
1922         FalseAlmCnt->Cnt_Parity_Fail = ((ret_value&0xffff0000)>>16);
1923
1924         ret_value = rtl8192_QueryBBReg(dev, rOFDM_PHYCounter2, bMaskDWord);
1925         FalseAlmCnt->Cnt_Rate_Illegal = (ret_value&0xffff);
1926         FalseAlmCnt->Cnt_Crc8_fail = ((ret_value&0xffff0000)>>16);
1927         ret_value = rtl8192_QueryBBReg(dev, rOFDM_PHYCounter3, bMaskDWord);
1928         FalseAlmCnt->Cnt_Mcs_fail = (ret_value&0xffff);
1929
1930         FalseAlmCnt->Cnt_Ofdm_fail = FalseAlmCnt->Cnt_Parity_Fail + FalseAlmCnt->Cnt_Rate_Illegal +
1931                                                           FalseAlmCnt->Cnt_Crc8_fail + FalseAlmCnt->Cnt_Mcs_fail;
1932
1933         ret_value = rtl8192_QueryBBReg(dev, 0xc64, bMaskDWord);
1934         FalseAlmCnt->Cnt_Cck_fail = (ret_value&0xffff);
1935         FalseAlmCnt->Cnt_all = (FalseAlmCnt->Cnt_Parity_Fail +
1936                                                 FalseAlmCnt->Cnt_Rate_Illegal +
1937                                                 FalseAlmCnt->Cnt_Crc8_fail +
1938                                                 FalseAlmCnt->Cnt_Mcs_fail +
1939                                                 FalseAlmCnt->Cnt_Cck_fail);
1940
1941         RT_TRACE(COMP_DIG, "Cnt_Ofdm_fail = %d, Cnt_Cck_fail = %d, Cnt_all = %d\n",
1942                                 FalseAlmCnt->Cnt_Ofdm_fail, FalseAlmCnt->Cnt_Cck_fail , FalseAlmCnt->Cnt_all);
1943 }
1944
1945 static void dm_ctrl_initgain_byrssi(struct net_device *dev)
1946 {
1947
1948         if (dm_digtable.dig_enable_flag == false)
1949                 return;
1950
1951         if (dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM)
1952                 dm_ctrl_initgain_byrssi_by_fwfalse_alarm(dev);
1953         else if (dm_digtable.dig_algorithm == DIG_ALGO_BY_RSSI)
1954                 dm_ctrl_initgain_byrssi_by_driverrssi(dev);
1955         else
1956                 return;
1957 }
1958
1959 /*-----------------------------------------------------------------------------
1960  * Function:    dm_CtrlInitGainBeforeConnectByRssiAndFalseAlarm()
1961  *
1962  * Overview:    Driver monitor RSSI and False Alarm to change initial gain.
1963                         Only change initial gain during link in progress.
1964  *
1965  * Input:               IN      PADAPTER        pAdapter
1966  *
1967  * Output:              NONE
1968  *
1969  * Return:              NONE
1970  *
1971  * Revised History:
1972  *      When            Who             Remark
1973  *      03/04/2009      hpfan   Create Version 0.
1974  *
1975  *---------------------------------------------------------------------------*/
1976
1977 static void dm_ctrl_initgain_byrssi_by_driverrssi(
1978         struct net_device *dev)
1979 {
1980         struct r8192_priv *priv = rtllib_priv(dev);
1981         u8 i;
1982         static u8       fw_dig=0;
1983
1984         if (dm_digtable.dig_enable_flag == false)
1985                 return;
1986
1987         if (dm_digtable.dig_algorithm_switch)
1988                 fw_dig = 0;
1989         if (fw_dig <= 3)
1990         {
1991                 for (i=0; i<3; i++)
1992                         rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8);
1993                 fw_dig++;
1994                 dm_digtable.dig_state = DM_STA_DIG_OFF;
1995         }
1996
1997         if (priv->rtllib->state == RTLLIB_LINKED)
1998                 dm_digtable.CurSTAConnectState = DIG_STA_CONNECT;
1999         else
2000                 dm_digtable.CurSTAConnectState = DIG_STA_DISCONNECT;
2001
2002
2003         if (dm_digtable.dbg_mode == DM_DBG_OFF)
2004                 dm_digtable.rssi_val = priv->undecorated_smoothed_pwdb;
2005         dm_initial_gain(dev);
2006         dm_pd_th(dev);
2007         dm_cs_ratio(dev);
2008         if (dm_digtable.dig_algorithm_switch)
2009                 dm_digtable.dig_algorithm_switch = 0;
2010         dm_digtable.PreSTAConnectState = dm_digtable.CurSTAConnectState;
2011
2012 }
2013
2014 static void dm_ctrl_initgain_byrssi_by_fwfalse_alarm(
2015         struct net_device *dev)
2016 {
2017         struct r8192_priv *priv = rtllib_priv(dev);
2018         static u32 reset_cnt = 0;
2019         u8 i;
2020
2021         if (dm_digtable.dig_enable_flag == false)
2022                 return;
2023
2024         if (dm_digtable.dig_algorithm_switch)
2025         {
2026                 dm_digtable.dig_state = DM_STA_DIG_MAX;
2027                 for (i=0; i<3; i++)
2028                         rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1);
2029                 dm_digtable.dig_algorithm_switch = 0;
2030         }
2031
2032         if (priv->rtllib->state != RTLLIB_LINKED)
2033                 return;
2034
2035         if ((priv->undecorated_smoothed_pwdb > dm_digtable.rssi_low_thresh) &&
2036                 (priv->undecorated_smoothed_pwdb < dm_digtable.rssi_high_thresh))
2037         {
2038                 return;
2039         }
2040         if ((priv->undecorated_smoothed_pwdb <= dm_digtable.rssi_low_thresh))
2041         {
2042                 if (dm_digtable.dig_state == DM_STA_DIG_OFF &&
2043                         (priv->reset_count == reset_cnt))
2044                 {
2045                         return;
2046                 }
2047                 else
2048                 {
2049                         reset_cnt = priv->reset_count;
2050                 }
2051
2052                 dm_digtable.dig_highpwr_state = DM_STA_DIG_MAX;
2053                 dm_digtable.dig_state = DM_STA_DIG_OFF;
2054
2055                 rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8);
2056
2057                 write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x17);
2058                 write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x17);
2059                 write_nic_byte(dev, rOFDM0_XCAGCCore1, 0x17);
2060                 write_nic_byte(dev, rOFDM0_XDAGCCore1, 0x17);
2061
2062                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2063                 {
2064                                 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x00);
2065                 }
2066                 else
2067                         write_nic_byte(dev, rOFDM0_RxDetector1, 0x42);
2068
2069                 write_nic_byte(dev, 0xa0a, 0x08);
2070
2071                 return;
2072
2073         }
2074
2075         if ((priv->undecorated_smoothed_pwdb >= dm_digtable.rssi_high_thresh) )
2076         {
2077                 u8 reset_flag = 0;
2078
2079                 if (dm_digtable.dig_state == DM_STA_DIG_ON &&
2080                         (priv->reset_count == reset_cnt))
2081                 {
2082                         dm_ctrl_initgain_byrssi_highpwr(dev);
2083                         return;
2084                 }
2085                 else
2086                 {
2087                         if (priv->reset_count != reset_cnt)
2088                                 reset_flag = 1;
2089
2090                         reset_cnt = priv->reset_count;
2091                 }
2092
2093                 dm_digtable.dig_state = DM_STA_DIG_ON;
2094
2095                 if (reset_flag == 1)
2096                 {
2097                         write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x2c);
2098                         write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x2c);
2099                         write_nic_byte(dev, rOFDM0_XCAGCCore1, 0x2c);
2100                         write_nic_byte(dev, rOFDM0_XDAGCCore1, 0x2c);
2101                 }
2102                 else
2103                 {
2104                 write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x20);
2105                 write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x20);
2106                 write_nic_byte(dev, rOFDM0_XCAGCCore1, 0x20);
2107                 write_nic_byte(dev, rOFDM0_XDAGCCore1, 0x20);
2108                 }
2109
2110                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2111                 {
2112                                 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x20);
2113                 }
2114                 else
2115                         write_nic_byte(dev, rOFDM0_RxDetector1, 0x44);
2116
2117                 write_nic_byte(dev, 0xa0a, 0xcd);
2118
2119
2120                 rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1);
2121
2122         }
2123
2124         dm_ctrl_initgain_byrssi_highpwr(dev);
2125
2126 }
2127
2128
2129 static void dm_ctrl_initgain_byrssi_highpwr(
2130         struct net_device * dev)
2131 {
2132         struct r8192_priv *priv = rtllib_priv(dev);
2133         static u32 reset_cnt_highpwr = 0;
2134
2135         if ((priv->undecorated_smoothed_pwdb > dm_digtable.rssi_high_power_lowthresh) &&
2136                 (priv->undecorated_smoothed_pwdb < dm_digtable.rssi_high_power_highthresh))
2137         {
2138                 return;
2139         }
2140
2141         if (priv->undecorated_smoothed_pwdb >= dm_digtable.rssi_high_power_highthresh)
2142         {
2143                 if (dm_digtable.dig_highpwr_state == DM_STA_DIG_ON &&
2144                         (priv->reset_count == reset_cnt_highpwr))
2145                         return;
2146                 else
2147                         dm_digtable.dig_highpwr_state = DM_STA_DIG_ON;
2148
2149                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2150                 {
2151                                 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x10);
2152                 }
2153                 else
2154                         write_nic_byte(dev, rOFDM0_RxDetector1, 0x43);
2155         }
2156         else
2157         {
2158                 if (dm_digtable.dig_highpwr_state == DM_STA_DIG_OFF&&
2159                         (priv->reset_count == reset_cnt_highpwr))
2160                         return;
2161                 else
2162                         dm_digtable.dig_highpwr_state = DM_STA_DIG_OFF;
2163
2164                 if (priv->undecorated_smoothed_pwdb < dm_digtable.rssi_high_power_lowthresh &&
2165                          priv->undecorated_smoothed_pwdb >= dm_digtable.rssi_high_thresh)
2166                 {
2167                         if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2168                         {
2169                                         write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x20);
2170                         }
2171                         else
2172                                 write_nic_byte(dev, rOFDM0_RxDetector1, 0x44);
2173                 }
2174         }
2175
2176         reset_cnt_highpwr = priv->reset_count;
2177
2178 }
2179
2180
2181 static void dm_initial_gain(
2182         struct net_device * dev)
2183 {
2184         struct r8192_priv *priv = rtllib_priv(dev);
2185         u8                                      initial_gain=0;
2186         static u8                               initialized=0, force_write=0;
2187         static u32                      reset_cnt=0;
2188
2189         if (dm_digtable.dig_algorithm_switch)
2190         {
2191                 initialized = 0;
2192                 reset_cnt = 0;
2193         }
2194
2195         if (rtllib_act_scanning(priv->rtllib,true) == true)
2196         {
2197                 force_write = 1;
2198                 return;
2199         }
2200
2201         if (dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState)
2202         {
2203                 if (dm_digtable.CurSTAConnectState == DIG_STA_CONNECT)
2204                 {
2205                         if ((dm_digtable.rssi_val+10-dm_digtable.backoff_val) > dm_digtable.rx_gain_range_max)
2206                                 dm_digtable.cur_ig_value = dm_digtable.rx_gain_range_max;
2207                         else if ((dm_digtable.rssi_val+10-dm_digtable.backoff_val) < dm_digtable.rx_gain_range_min)
2208                                 dm_digtable.cur_ig_value = dm_digtable.rx_gain_range_min;
2209                         else
2210                                 dm_digtable.cur_ig_value = dm_digtable.rssi_val+10-dm_digtable.backoff_val;
2211                 }
2212                 else
2213                 {
2214                         if (dm_digtable.cur_ig_value == 0)
2215                                 dm_digtable.cur_ig_value = priv->DefaultInitialGain[0];
2216                         else
2217                                 dm_digtable.cur_ig_value = dm_digtable.pre_ig_value;
2218                 }
2219         }
2220         else
2221         {
2222                 dm_digtable.cur_ig_value = priv->DefaultInitialGain[0];
2223                 dm_digtable.pre_ig_value = 0;
2224         }
2225
2226         if (priv->reset_count != reset_cnt)
2227         {
2228                 force_write = 1;
2229                 reset_cnt = priv->reset_count;
2230         }
2231
2232         if (dm_digtable.pre_ig_value != read_nic_byte(dev, rOFDM0_XAAGCCore1))
2233                 force_write = 1;
2234
2235         {
2236                 if ((dm_digtable.pre_ig_value != dm_digtable.cur_ig_value)
2237                         || !initialized || force_write)
2238                 {
2239                         initial_gain = (u8)dm_digtable.cur_ig_value;
2240                         write_nic_byte(dev, rOFDM0_XAAGCCore1, initial_gain);
2241                         write_nic_byte(dev, rOFDM0_XBAGCCore1, initial_gain);
2242                         write_nic_byte(dev, rOFDM0_XCAGCCore1, initial_gain);
2243                         write_nic_byte(dev, rOFDM0_XDAGCCore1, initial_gain);
2244                         dm_digtable.pre_ig_value = dm_digtable.cur_ig_value;
2245                         initialized = 1;
2246                         force_write = 0;
2247                 }
2248         }
2249 }
2250
2251 void dm_initial_gain_STABeforeConnect(
2252         struct net_device * dev)
2253 {
2254         struct r8192_priv *priv = rtllib_priv(dev);
2255         u8                      initial_gain=0;
2256         static u8               initialized=0, force_write=0;
2257
2258         RT_TRACE(COMP_DIG, "PreSTAConnectState = %x, CurSTAConnectState = %x\n",
2259                                 dm_digtable.PreSTAConnectState, dm_digtable.CurSTAConnectState);
2260
2261
2262         if ((dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState) ||
2263                 (dm_digtable.CurSTAConnectState == DIG_STA_BEFORE_CONNECT))
2264         {
2265                 if (dm_digtable.CurSTAConnectState == DIG_STA_BEFORE_CONNECT)
2266                 {
2267                         if (priv->rtllib->eRFPowerState != eRfOn)
2268                                 return;
2269
2270                         if (dm_digtable.Backoff_Enable_Flag == true)
2271                         {
2272                                 if (priv->FalseAlmCnt.Cnt_all > dm_digtable.FAHighThresh)
2273                                 {
2274                                         if ((dm_digtable.backoff_val -6) < dm_digtable.BackoffVal_range_min)
2275                                                 dm_digtable.backoff_val = dm_digtable.BackoffVal_range_min;
2276                                         else
2277                                                 dm_digtable.backoff_val -= 6;
2278                                 }
2279                                 else if (priv->FalseAlmCnt.Cnt_all < dm_digtable.FALowThresh)
2280                                 {
2281                                         if ((dm_digtable.backoff_val+6) > dm_digtable.BackoffVal_range_max)
2282                                                 dm_digtable.backoff_val = dm_digtable.BackoffVal_range_max;
2283                                         else
2284                                                 dm_digtable.backoff_val +=6;
2285                                 }
2286                         }
2287                         else
2288                                 dm_digtable.backoff_val =DM_DIG_BACKOFF;
2289
2290                         if ((dm_digtable.rssi_val+10-dm_digtable.backoff_val) > dm_digtable.rx_gain_range_max)
2291                                 dm_digtable.cur_ig_value = dm_digtable.rx_gain_range_max;
2292                         else if ((dm_digtable.rssi_val+10-dm_digtable.backoff_val) < dm_digtable.rx_gain_range_min)
2293                                 dm_digtable.cur_ig_value = dm_digtable.rx_gain_range_min;
2294                         else
2295                                 dm_digtable.cur_ig_value = dm_digtable.rssi_val+10-dm_digtable.backoff_val;
2296
2297                         if (priv->FalseAlmCnt.Cnt_all > 10000)
2298                                 dm_digtable.cur_ig_value = (dm_digtable.cur_ig_value>0x33)?dm_digtable.cur_ig_value:0x33;
2299
2300                         if (priv->FalseAlmCnt.Cnt_all > 16000)
2301                                 dm_digtable.cur_ig_value = dm_digtable.rx_gain_range_max;
2302
2303                 }
2304                 else
2305                 {
2306                         return;
2307                 }
2308         }
2309         else
2310         {
2311                 dm_digtable.Dig_Ext_Port_Stage = DIG_EXT_PORT_STAGE_MAX;
2312                 priv->rtllib->SetFwCmdHandler(dev, FW_CMD_DIG_ENABLE);
2313
2314                 dm_digtable.backoff_val = DM_DIG_BACKOFF;
2315                 dm_digtable.cur_ig_value = priv->DefaultInitialGain[0];
2316                 dm_digtable.pre_ig_value = 0;
2317                 return;
2318         }
2319
2320         if (dm_digtable.pre_ig_value != rtl8192_QueryBBReg(dev, rOFDM0_XAAGCCore1, bMaskByte0))
2321                 force_write = 1;
2322
2323         if ((dm_digtable.pre_ig_value != dm_digtable.cur_ig_value) || !initialized || force_write)
2324         {
2325                 priv->rtllib->SetFwCmdHandler(dev, FW_CMD_DIG_DISABLE);
2326
2327                 initial_gain = (u8)dm_digtable.cur_ig_value;
2328
2329                 rtl8192_setBBreg(dev, rOFDM0_XAAGCCore1, bMaskByte0, initial_gain);
2330                 rtl8192_setBBreg(dev, rOFDM0_XBAGCCore1, bMaskByte0, initial_gain);
2331                 dm_digtable.pre_ig_value = dm_digtable.cur_ig_value;
2332                 initialized = 1;
2333                 force_write = 0;
2334         }
2335
2336         RT_TRACE(COMP_DIG, "CurIGValue = 0x%x, pre_ig_value = 0x%x, backoff_val = %d\n",
2337                                 dm_digtable.cur_ig_value, dm_digtable.pre_ig_value, dm_digtable.backoff_val);
2338
2339 }
2340
2341 static void dm_pd_th(
2342         struct net_device * dev)
2343 {
2344         struct r8192_priv *priv = rtllib_priv(dev);
2345         static u8                               initialized=0, force_write=0;
2346         static u32                      reset_cnt = 0;
2347
2348         if (dm_digtable.dig_algorithm_switch)
2349         {
2350                 initialized = 0;
2351                 reset_cnt = 0;
2352         }
2353
2354         if (dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState)
2355         {
2356                 if (dm_digtable.CurSTAConnectState == DIG_STA_CONNECT)
2357                 {
2358                         if (dm_digtable.rssi_val >= dm_digtable.rssi_high_power_highthresh)
2359                                 dm_digtable.curpd_thstate = DIG_PD_AT_HIGH_POWER;
2360                         else if ((dm_digtable.rssi_val <= dm_digtable.rssi_low_thresh))
2361                                 dm_digtable.curpd_thstate = DIG_PD_AT_LOW_POWER;
2362                         else if ((dm_digtable.rssi_val >= dm_digtable.rssi_high_thresh) &&
2363                                         (dm_digtable.rssi_val < dm_digtable.rssi_high_power_lowthresh))
2364                                 dm_digtable.curpd_thstate = DIG_PD_AT_NORMAL_POWER;
2365                         else
2366                                 dm_digtable.curpd_thstate = dm_digtable.prepd_thstate;
2367                 }
2368                 else
2369                 {
2370                         dm_digtable.curpd_thstate = DIG_PD_AT_LOW_POWER;
2371                 }
2372         }
2373         else
2374         {
2375                 dm_digtable.curpd_thstate = DIG_PD_AT_LOW_POWER;
2376         }
2377
2378         if (priv->reset_count != reset_cnt)
2379         {
2380                 force_write = 1;
2381                 reset_cnt = priv->reset_count;
2382         }
2383
2384         {
2385                 if ((dm_digtable.prepd_thstate != dm_digtable.curpd_thstate) ||
2386                         (initialized<=3) || force_write)
2387                 {
2388                         if (dm_digtable.curpd_thstate == DIG_PD_AT_LOW_POWER)
2389                         {
2390                                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2391                                 {
2392                                                 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x00);
2393                                 }
2394                                 else
2395                                         write_nic_byte(dev, rOFDM0_RxDetector1, 0x42);
2396                         }
2397                         else if (dm_digtable.curpd_thstate == DIG_PD_AT_NORMAL_POWER)
2398                         {
2399                                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2400                                 {
2401                                                 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x20);
2402                                 }
2403                                 else
2404                                         write_nic_byte(dev, rOFDM0_RxDetector1, 0x44);
2405                         }
2406                         else if (dm_digtable.curpd_thstate == DIG_PD_AT_HIGH_POWER)
2407                         {
2408                                 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
2409                                 {
2410                                                 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x10);
2411                                 }
2412                                 else
2413                                         write_nic_byte(dev, rOFDM0_RxDetector1, 0x43);
2414                         }
2415                         dm_digtable.prepd_thstate = dm_digtable.curpd_thstate;
2416                         if (initialized <= 3)
2417                                 initialized++;
2418                         force_write = 0;
2419                 }
2420         }
2421 }
2422
2423 static  void dm_cs_ratio(
2424         struct net_device * dev)
2425 {
2426         struct r8192_priv *priv = rtllib_priv(dev);
2427         static u8                               initialized=0,force_write=0;
2428         static u32                      reset_cnt = 0;
2429
2430         if (dm_digtable.dig_algorithm_switch)
2431         {
2432                 initialized = 0;
2433                 reset_cnt = 0;
2434         }
2435
2436         if (dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState)
2437         {
2438                 if (dm_digtable.CurSTAConnectState == DIG_STA_CONNECT)
2439                 {
2440                         if ((dm_digtable.rssi_val <= dm_digtable.rssi_low_thresh))
2441                                 dm_digtable.curcs_ratio_state = DIG_CS_RATIO_LOWER;
2442                         else if ((dm_digtable.rssi_val >= dm_digtable.rssi_high_thresh) )
2443                                 dm_digtable.curcs_ratio_state = DIG_CS_RATIO_HIGHER;
2444                         else
2445                                 dm_digtable.curcs_ratio_state = dm_digtable.precs_ratio_state;
2446                 }
2447                 else
2448                 {
2449                         dm_digtable.curcs_ratio_state = DIG_CS_RATIO_LOWER;
2450                 }
2451         }
2452         else
2453         {
2454                 dm_digtable.curcs_ratio_state = DIG_CS_RATIO_LOWER;
2455         }
2456
2457         if (priv->reset_count != reset_cnt)
2458         {
2459                 force_write = 1;
2460                 reset_cnt = priv->reset_count;
2461         }
2462
2463
2464         {
2465                 if ((dm_digtable.precs_ratio_state != dm_digtable.curcs_ratio_state) ||
2466                         !initialized || force_write)
2467                 {
2468                         if (dm_digtable.curcs_ratio_state == DIG_CS_RATIO_LOWER)
2469                         {
2470                                 write_nic_byte(dev, 0xa0a, 0x08);
2471                         }
2472                         else if (dm_digtable.curcs_ratio_state == DIG_CS_RATIO_HIGHER)
2473                         {
2474                                 write_nic_byte(dev, 0xa0a, 0xcd);
2475                         }
2476                         dm_digtable.precs_ratio_state = dm_digtable.curcs_ratio_state;
2477                         initialized = 1;
2478                         force_write = 0;
2479                 }
2480         }
2481 }
2482
2483 extern void dm_init_edca_turbo(struct net_device * dev)
2484 {
2485         struct r8192_priv *priv = rtllib_priv(dev);
2486
2487         priv->bcurrent_turbo_EDCA = false;
2488         priv->rtllib->bis_any_nonbepkts = false;
2489         priv->bis_cur_rdlstate = false;
2490 }
2491
2492 static void dm_check_edca_turbo(
2493         struct net_device * dev)
2494 {
2495         struct r8192_priv *priv = rtllib_priv(dev);
2496         struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
2497
2498         static unsigned long                    lastTxOkCnt = 0;
2499         static unsigned long                    lastRxOkCnt = 0;
2500         unsigned long                           curTxOkCnt = 0;
2501         unsigned long                           curRxOkCnt = 0;
2502
2503         if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
2504         {
2505                 goto dm_CheckEdcaTurbo_EXIT;
2506         }
2507         if (priv->rtllib->state != RTLLIB_LINKED)
2508         {
2509                 goto dm_CheckEdcaTurbo_EXIT;
2510         }
2511         if (priv->rtllib->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_EDCA_TURBO)
2512         {
2513                 goto dm_CheckEdcaTurbo_EXIT;
2514         }
2515
2516         {
2517                 u8* peername[11] = {"unknown", "realtek_90", "realtek_92se","broadcom", "ralink", "atheros", "cisco", "marvell", "92u_softap", "self_softap"};
2518                 static int wb_tmp = 0;
2519                 if (wb_tmp == 0){
2520                         printk("%s():iot peer is %s, bssid:"MAC_FMT"\n",__func__,peername[pHTInfo->IOTPeer], MAC_ARG(priv->rtllib->current_network.bssid));
2521                         wb_tmp = 1;
2522                 }
2523         }
2524         if (!priv->rtllib->bis_any_nonbepkts)
2525         {
2526                 curTxOkCnt = priv->stats.txbytesunicast - lastTxOkCnt;
2527                 curRxOkCnt = priv->stats.rxbytesunicast - lastRxOkCnt;
2528                 if (pHTInfo->IOTAction & HT_IOT_ACT_EDCA_BIAS_ON_RX)
2529                 {
2530                         if (curTxOkCnt > 4*curRxOkCnt)
2531                         {
2532                                 if (priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA)
2533                                 {
2534                                         write_nic_dword(dev, EDCAPARA_BE, edca_setting_UL[pHTInfo->IOTPeer]);
2535                                         priv->bis_cur_rdlstate = false;
2536                                 }
2537                         }
2538                         else
2539                         {
2540                                 if (!priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA)
2541                                 {
2542                                         if (priv->rtllib->mode == WIRELESS_MODE_G)
2543                                                 write_nic_dword(dev, EDCAPARA_BE, edca_setting_DL_GMode[pHTInfo->IOTPeer]);
2544                                         else
2545                                                 write_nic_dword(dev, EDCAPARA_BE, edca_setting_DL[pHTInfo->IOTPeer]);
2546                                         priv->bis_cur_rdlstate = true;
2547                                 }
2548                         }
2549                         priv->bcurrent_turbo_EDCA = true;
2550                 }
2551                 else
2552                 {
2553                 if (curRxOkCnt > 4*curTxOkCnt)
2554                 {
2555                         if (!priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA)
2556                         {
2557                                 if (priv->rtllib->mode == WIRELESS_MODE_G)
2558                                         write_nic_dword(dev, EDCAPARA_BE, edca_setting_DL_GMode[pHTInfo->IOTPeer]);
2559                                 else
2560                                 write_nic_dword(dev, EDCAPARA_BE, edca_setting_DL[pHTInfo->IOTPeer]);
2561                                 priv->bis_cur_rdlstate = true;
2562                         }
2563                 }
2564                 else
2565                 {
2566                         if (priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA)
2567                         {
2568                                 write_nic_dword(dev, EDCAPARA_BE, edca_setting_UL[pHTInfo->IOTPeer]);
2569                                 priv->bis_cur_rdlstate = false;
2570                         }
2571
2572                 }
2573
2574                 priv->bcurrent_turbo_EDCA = true;
2575         }
2576         }
2577         else
2578         {
2579                  if (priv->bcurrent_turbo_EDCA)
2580                 {
2581
2582                          u8 tmp = AC0_BE;
2583                          priv->rtllib->SetHwRegHandler(dev, HW_VAR_AC_PARAM, (u8*)(&tmp) );
2584                         priv->bcurrent_turbo_EDCA = false;
2585                 }
2586         }
2587
2588
2589 dm_CheckEdcaTurbo_EXIT:
2590         priv->rtllib->bis_any_nonbepkts = false;
2591         lastTxOkCnt = priv->stats.txbytesunicast;
2592         lastRxOkCnt = priv->stats.rxbytesunicast;
2593 }
2594
2595 extern void DM_CTSToSelfSetting(struct net_device * dev,u32 DM_Type, u32 DM_Value)
2596 {
2597         struct r8192_priv *priv = rtllib_priv((struct net_device *)dev);
2598
2599         if (DM_Type == 0)
2600         {
2601                 if (DM_Value > 1)
2602                         DM_Value = 1;
2603                 priv->rtllib->bCTSToSelfEnable = (bool)DM_Value;
2604         }
2605         else if (DM_Type == 1)
2606         {
2607                 if (DM_Value >= 50)
2608                         DM_Value = 50;
2609                 priv->rtllib->CTSToSelfTH = (u8)DM_Value;
2610         }
2611 }
2612
2613 static void dm_init_ctstoself(struct net_device * dev)
2614 {
2615         struct r8192_priv *priv = rtllib_priv((struct net_device *)dev);
2616
2617         priv->rtllib->bCTSToSelfEnable = true;
2618         priv->rtllib->CTSToSelfTH = CTSToSelfTHVal;
2619 }
2620
2621 static void dm_ctstoself(struct net_device *dev)
2622 {
2623         struct r8192_priv *priv = rtllib_priv((struct net_device *)dev);
2624         struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
2625         static unsigned long                            lastTxOkCnt = 0;
2626         static unsigned long                            lastRxOkCnt = 0;
2627         unsigned long                                           curTxOkCnt = 0;
2628         unsigned long                                           curRxOkCnt = 0;
2629
2630         if (priv->rtllib->bCTSToSelfEnable != true)
2631         {
2632                 pHTInfo->IOTAction &= ~HT_IOT_ACT_FORCED_CTS2SELF;
2633                 return;
2634         }
2635         if (pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
2636         {
2637                 curTxOkCnt = priv->stats.txbytesunicast - lastTxOkCnt;
2638                 curRxOkCnt = priv->stats.rxbytesunicast - lastRxOkCnt;
2639                 if (curRxOkCnt > 4*curTxOkCnt)
2640                 {
2641                         pHTInfo->IOTAction &= ~HT_IOT_ACT_FORCED_CTS2SELF;
2642                 }
2643                 else
2644                 {
2645                         pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_CTS2SELF;
2646                 }
2647
2648                 lastTxOkCnt = priv->stats.txbytesunicast;
2649                 lastRxOkCnt = priv->stats.rxbytesunicast;
2650         }
2651 }
2652
2653
2654 static  void
2655 dm_Init_WA_Broadcom_IOT(struct net_device * dev)
2656 {
2657         struct r8192_priv *priv = rtllib_priv((struct net_device *)dev);
2658         struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
2659
2660         pHTInfo->bWAIotBroadcom = false;
2661         pHTInfo->WAIotTH = WAIotTHVal;
2662 }
2663
2664 static  void    dm_check_pbc_gpio(struct net_device *dev)
2665 {
2666 }
2667
2668
2669 extern  void    dm_CheckRfCtrlGPIO(void *data)
2670 {
2671        struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv,gpio_change_rf_wq);
2672        struct net_device *dev = priv->rtllib->dev;
2673         u8 tmp1byte;
2674         enum rt_rf_power_state eRfPowerStateToSet;
2675         bool bActuallySet = false;
2676
2677         char *argv[3];
2678         static char *RadioPowerPath = "/etc/acpi/events/RadioPower.sh";
2679         static char *envp[] = {"HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL};
2680
2681         bActuallySet=false;
2682
2683         if ((priv->up_first_time == 1) || (priv->being_init_adapter))
2684         {
2685                 return;
2686         }
2687
2688         if (priv->bfirst_after_down){
2689                 priv->bfirst_after_down = 1;
2690                 return;
2691         }
2692
2693
2694
2695         {
2696                 tmp1byte = read_nic_byte(dev,GPI);
2697
2698                 eRfPowerStateToSet = (tmp1byte&BIT1) ?  eRfOn : eRfOff;
2699
2700                 if ( (priv->bHwRadioOff == true) && (eRfPowerStateToSet == eRfOn))
2701                 {
2702                         RT_TRACE(COMP_RF, "gpiochangeRF  - HW Radio ON\n");
2703                         printk("gpiochangeRF  - HW Radio ON\n");
2704                         priv->bHwRadioOff = false;
2705                         bActuallySet = true;
2706                 }
2707                 else if ( (priv->bHwRadioOff == false) && (eRfPowerStateToSet == eRfOff))
2708                 {
2709                         RT_TRACE(COMP_RF, "gpiochangeRF  - HW Radio OFF\n");
2710                         printk("gpiochangeRF  - HW Radio OFF\n");
2711                         priv->bHwRadioOff = true;
2712                         bActuallySet = true;
2713                 }
2714
2715                 if (bActuallySet)
2716                 {
2717                         mdelay(1000);
2718                         priv->bHwRfOffAction = 1;
2719                         MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW,true);
2720                         {
2721                                 if (priv->bHwRadioOff == true)
2722                                         argv[1] = "RFOFF";
2723                                 else
2724                                         argv[1] = "RFON";
2725
2726                                 argv[0] = RadioPowerPath;
2727                                 argv[2] = NULL;
2728                                 call_usermodehelper(RadioPowerPath,argv,envp,1);
2729                         }
2730
2731                 }
2732         }
2733
2734 }
2735
2736 void    dm_rf_pathcheck_workitemcallback(void *data)
2737 {
2738         struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv,rfpath_check_wq);
2739         struct net_device *dev =priv->rtllib->dev;
2740         u8 rfpath = 0, i;
2741
2742         rfpath = read_nic_byte(dev, 0xc04);
2743
2744         for (i = 0; i < RF90_PATH_MAX; i++) {
2745                 if (rfpath & (0x01<<i))
2746                         priv->brfpath_rxenable[i] = 1;
2747                 else
2748                         priv->brfpath_rxenable[i] = 0;
2749         }
2750         if (!DM_RxPathSelTable.Enable)
2751                 return;
2752
2753         dm_rxpath_sel_byrssi(dev);
2754 }
2755
2756 static void dm_init_rxpath_selection(struct net_device * dev)
2757 {
2758         u8 i;
2759         struct r8192_priv *priv = rtllib_priv(dev);
2760         DM_RxPathSelTable.Enable = 1;
2761         DM_RxPathSelTable.SS_TH_low = RxPathSelection_SS_TH_low;
2762         DM_RxPathSelTable.diff_TH = RxPathSelection_diff_TH;
2763         if (priv->CustomerID == RT_CID_819x_Netcore)
2764                 DM_RxPathSelTable.cck_method = CCK_Rx_Version_2;
2765         else
2766                 DM_RxPathSelTable.cck_method = CCK_Rx_Version_1;
2767         DM_RxPathSelTable.DbgMode = DM_DBG_OFF;
2768         DM_RxPathSelTable.disabledRF = 0;
2769         for (i=0; i<4; i++)
2770         {
2771                 DM_RxPathSelTable.rf_rssi[i] = 50;
2772                 DM_RxPathSelTable.cck_pwdb_sta[i] = -64;
2773                 DM_RxPathSelTable.rf_enable_rssi_th[i] = 100;
2774         }
2775 }
2776
2777 static void dm_rxpath_sel_byrssi(struct net_device * dev)
2778 {
2779         struct r8192_priv *priv = rtllib_priv(dev);
2780         u8                              i, max_rssi_index=0, min_rssi_index=0, sec_rssi_index=0, rf_num=0;
2781         u8                              tmp_max_rssi=0, tmp_min_rssi=0, tmp_sec_rssi=0;
2782         u8                              cck_default_Rx=0x2;
2783         u8                              cck_optional_Rx=0x3;
2784         long                            tmp_cck_max_pwdb=0, tmp_cck_min_pwdb=0, tmp_cck_sec_pwdb=0;
2785         u8                              cck_rx_ver2_max_index=0, cck_rx_ver2_min_index=0, cck_rx_ver2_sec_index=0;
2786         u8                              cur_rf_rssi;
2787         long                            cur_cck_pwdb;
2788         static u8                       disabled_rf_cnt=0, cck_Rx_Path_initialized=0;
2789         u8                              update_cck_rx_path;
2790
2791         if (priv->rf_type != RF_2T4R)
2792                 return;
2793
2794         if (!cck_Rx_Path_initialized)
2795         {
2796                 DM_RxPathSelTable.cck_Rx_path = (read_nic_byte(dev, 0xa07)&0xf);
2797                 cck_Rx_Path_initialized = 1;
2798         }
2799
2800         DM_RxPathSelTable.disabledRF = 0xf;
2801         DM_RxPathSelTable.disabledRF &=~ (read_nic_byte(dev, 0xc04));
2802
2803         if (priv->rtllib->mode == WIRELESS_MODE_B)
2804         {
2805                 DM_RxPathSelTable.cck_method = CCK_Rx_Version_2;
2806         }
2807
2808         for (i=0; i<RF90_PATH_MAX; i++)
2809         {
2810                 if (!DM_RxPathSelTable.DbgMode)
2811                         DM_RxPathSelTable.rf_rssi[i] = priv->stats.rx_rssi_percentage[i];
2812
2813                 if (priv->brfpath_rxenable[i])
2814                 {
2815                         rf_num++;
2816                         cur_rf_rssi = DM_RxPathSelTable.rf_rssi[i];
2817
2818                         if (rf_num == 1)
2819                         {
2820                                 max_rssi_index = min_rssi_index = sec_rssi_index = i;
2821                                 tmp_max_rssi = tmp_min_rssi = tmp_sec_rssi = cur_rf_rssi;
2822                         }
2823                         else if (rf_num == 2)
2824                         {
2825                                 if (cur_rf_rssi >= tmp_max_rssi)
2826                                 {
2827                                         tmp_max_rssi = cur_rf_rssi;
2828                                         max_rssi_index = i;
2829                                 }
2830                                 else
2831                                 {
2832                                         tmp_sec_rssi = tmp_min_rssi = cur_rf_rssi;
2833                                         sec_rssi_index = min_rssi_index = i;
2834                                 }
2835                         }
2836                         else
2837                         {
2838                                 if (cur_rf_rssi > tmp_max_rssi)
2839                                 {
2840                                         tmp_sec_rssi = tmp_max_rssi;
2841                                         sec_rssi_index = max_rssi_index;
2842                                         tmp_max_rssi = cur_rf_rssi;
2843                                         max_rssi_index = i;
2844                                 }
2845                                 else if (cur_rf_rssi == tmp_max_rssi)
2846                                 {
2847                                         tmp_sec_rssi = cur_rf_rssi;
2848                                         sec_rssi_index = i;
2849                                 }
2850                                 else if ((cur_rf_rssi < tmp_max_rssi) &&(cur_rf_rssi > tmp_sec_rssi))
2851                                 {
2852                                         tmp_sec_rssi = cur_rf_rssi;
2853                                         sec_rssi_index = i;
2854                                 }
2855                                 else if (cur_rf_rssi == tmp_sec_rssi)
2856                                 {
2857                                         if (tmp_sec_rssi == tmp_min_rssi)
2858                                         {
2859                                                 tmp_sec_rssi = cur_rf_rssi;
2860                                                 sec_rssi_index = i;
2861                                         }
2862                                         else
2863                                         {
2864                                         }
2865                                 }
2866                                 else if ((cur_rf_rssi < tmp_sec_rssi) && (cur_rf_rssi > tmp_min_rssi))
2867                                 {
2868                                 }
2869                                 else if (cur_rf_rssi == tmp_min_rssi)
2870                                 {
2871                                         if (tmp_sec_rssi == tmp_min_rssi)
2872                                         {
2873                                                 tmp_min_rssi = cur_rf_rssi;
2874                                                 min_rssi_index = i;
2875                                         }
2876                                         else
2877                                         {
2878                                         }
2879                                 }
2880                                 else if (cur_rf_rssi < tmp_min_rssi)
2881                                 {
2882                                         tmp_min_rssi = cur_rf_rssi;
2883                                         min_rssi_index = i;
2884                                 }
2885                         }
2886                 }
2887         }
2888
2889         rf_num = 0;
2890         if (DM_RxPathSelTable.cck_method == CCK_Rx_Version_2)
2891         {
2892                 for (i=0; i<RF90_PATH_MAX; i++)
2893                 {
2894                         if (priv->brfpath_rxenable[i])
2895                         {
2896                                 rf_num++;
2897                                 cur_cck_pwdb =  DM_RxPathSelTable.cck_pwdb_sta[i];
2898
2899                                 if (rf_num == 1)
2900                                 {
2901                                         cck_rx_ver2_max_index = cck_rx_ver2_min_index = cck_rx_ver2_sec_index = i;
2902                                         tmp_cck_max_pwdb = tmp_cck_min_pwdb = tmp_cck_sec_pwdb = cur_cck_pwdb;
2903                                 }
2904                                 else if (rf_num == 2)
2905                                 {
2906                                         if (cur_cck_pwdb >= tmp_cck_max_pwdb)
2907                                         {
2908                                                 tmp_cck_max_pwdb = cur_cck_pwdb;
2909                                                 cck_rx_ver2_max_index = i;
2910                                         }
2911                                         else
2912                                         {
2913                                                 tmp_cck_sec_pwdb = tmp_cck_min_pwdb = cur_cck_pwdb;
2914                                                 cck_rx_ver2_sec_index = cck_rx_ver2_min_index = i;
2915                                         }
2916                                 }
2917                                 else
2918                                 {
2919                                         if (cur_cck_pwdb > tmp_cck_max_pwdb)
2920                                         {
2921                                                 tmp_cck_sec_pwdb = tmp_cck_max_pwdb;
2922                                                 cck_rx_ver2_sec_index = cck_rx_ver2_max_index;
2923                                                 tmp_cck_max_pwdb = cur_cck_pwdb;
2924                                                 cck_rx_ver2_max_index = i;
2925                                         }
2926                                         else if (cur_cck_pwdb == tmp_cck_max_pwdb)
2927                                         {
2928                                                 tmp_cck_sec_pwdb = cur_cck_pwdb;
2929                                                 cck_rx_ver2_sec_index = i;
2930                                         }
2931                                         else if ((cur_cck_pwdb < tmp_cck_max_pwdb) &&(cur_cck_pwdb > tmp_cck_sec_pwdb))
2932                                         {
2933                                                 tmp_cck_sec_pwdb = cur_cck_pwdb;
2934                                                 cck_rx_ver2_sec_index = i;
2935                                         }
2936                                         else if (cur_cck_pwdb == tmp_cck_sec_pwdb)
2937                                         {
2938                                                 if (tmp_cck_sec_pwdb == tmp_cck_min_pwdb)
2939                                                 {
2940                                                         tmp_cck_sec_pwdb = cur_cck_pwdb;
2941                                                         cck_rx_ver2_sec_index = i;
2942                                                 }
2943                                                 else
2944                                                 {
2945                                                 }
2946                                         }
2947                                         else if ((cur_cck_pwdb < tmp_cck_sec_pwdb) && (cur_cck_pwdb > tmp_cck_min_pwdb))
2948                                         {
2949                                         }
2950                                         else if (cur_cck_pwdb == tmp_cck_min_pwdb)
2951                                         {
2952                                                 if (tmp_cck_sec_pwdb == tmp_cck_min_pwdb)
2953                                                 {
2954                                                         tmp_cck_min_pwdb = cur_cck_pwdb;
2955                                                         cck_rx_ver2_min_index = i;
2956                                                 }
2957                                                 else
2958                                                 {
2959                                                 }
2960                                         }
2961                                         else if (cur_cck_pwdb < tmp_cck_min_pwdb)
2962                                         {
2963                                                 tmp_cck_min_pwdb = cur_cck_pwdb;
2964                                                 cck_rx_ver2_min_index = i;
2965                                         }
2966                                 }
2967
2968                         }
2969                 }
2970         }
2971
2972
2973         update_cck_rx_path = 0;
2974         if (DM_RxPathSelTable.cck_method == CCK_Rx_Version_2)
2975         {
2976                 cck_default_Rx = cck_rx_ver2_max_index;
2977                 cck_optional_Rx = cck_rx_ver2_sec_index;
2978                 if (tmp_cck_max_pwdb != -64)
2979                         update_cck_rx_path = 1;
2980         }
2981
2982         if (tmp_min_rssi < DM_RxPathSelTable.SS_TH_low && disabled_rf_cnt < 2)
2983         {
2984                 if ((tmp_max_rssi - tmp_min_rssi) >= DM_RxPathSelTable.diff_TH)
2985                 {
2986                         DM_RxPathSelTable.rf_enable_rssi_th[min_rssi_index] = tmp_max_rssi+5;
2987                         rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0x1<<min_rssi_index, 0x0);
2988                         rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0x1<<min_rssi_index, 0x0);
2989                         disabled_rf_cnt++;
2990                 }
2991                 if (DM_RxPathSelTable.cck_method == CCK_Rx_Version_1)
2992                 {
2993                         cck_default_Rx = max_rssi_index;
2994                         cck_optional_Rx = sec_rssi_index;
2995                         if (tmp_max_rssi)
2996                                 update_cck_rx_path = 1;
2997                 }
2998         }
2999
3000         if (update_cck_rx_path)
3001         {
3002                 DM_RxPathSelTable.cck_Rx_path = (cck_default_Rx<<2)|(cck_optional_Rx);
3003                 rtl8192_setBBreg(dev, rCCK0_AFESetting, 0x0f000000, DM_RxPathSelTable.cck_Rx_path);
3004         }
3005
3006         if (DM_RxPathSelTable.disabledRF)
3007         {
3008                 for (i=0; i<4; i++)
3009                 {
3010                         if ((DM_RxPathSelTable.disabledRF>>i) & 0x1)
3011                         {
3012                                 if (tmp_max_rssi >= DM_RxPathSelTable.rf_enable_rssi_th[i])
3013                                 {
3014                                         rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0x1<<i, 0x1);
3015                                         rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0x1<<i, 0x1);
3016                                         DM_RxPathSelTable.rf_enable_rssi_th[i] = 100;
3017                                         disabled_rf_cnt--;
3018                                 }
3019                         }
3020                 }
3021         }
3022 }
3023
3024 static  void    dm_check_rx_path_selection(struct net_device *dev)
3025 {
3026         struct r8192_priv *priv = rtllib_priv(dev);
3027         queue_delayed_work_rsl(priv->priv_wq,&priv->rfpath_check_wq,0);
3028 }
3029
3030
3031 static void dm_init_fsync (struct net_device *dev)
3032 {
3033         struct r8192_priv *priv = rtllib_priv(dev);
3034
3035         priv->rtllib->fsync_time_interval = 500;
3036         priv->rtllib->fsync_rate_bitmap = 0x0f000800;
3037         priv->rtllib->fsync_rssi_threshold = 30;
3038         priv->rtllib->bfsync_enable = false;
3039         priv->rtllib->fsync_multiple_timeinterval = 3;
3040         priv->rtllib->fsync_firstdiff_ratethreshold= 100;
3041         priv->rtllib->fsync_seconddiff_ratethreshold= 200;
3042         priv->rtllib->fsync_state = Default_Fsync;
3043         priv->framesyncMonitor = 1;
3044
3045         init_timer(&priv->fsync_timer);
3046         setup_timer(&priv->fsync_timer, dm_fsync_timer_callback,(unsigned long) dev);
3047 }
3048
3049
3050 static void dm_deInit_fsync(struct net_device *dev)
3051 {
3052         struct r8192_priv *priv = rtllib_priv(dev);
3053         del_timer_sync(&priv->fsync_timer);
3054 }
3055
3056 extern void dm_fsync_timer_callback(unsigned long data)
3057 {
3058         struct net_device *dev = (struct net_device *)data;
3059         struct r8192_priv *priv = rtllib_priv((struct net_device *)data);
3060         u32 rate_index, rate_count = 0, rate_count_diff=0;
3061         bool            bSwitchFromCountDiff = false;
3062         bool            bDoubleTimeInterval = false;
3063
3064         if (    priv->rtllib->state == RTLLIB_LINKED &&
3065                 priv->rtllib->bfsync_enable &&
3066                 (priv->rtllib->pHTInfo->IOTAction & HT_IOT_ACT_CDD_FSYNC))
3067         {
3068                 u32 rate_bitmap;
3069                 for (rate_index = 0; rate_index <= 27; rate_index++)
3070                 {
3071                         rate_bitmap  = 1 << rate_index;
3072                         if (priv->rtllib->fsync_rate_bitmap &  rate_bitmap)
3073                                 rate_count+= priv->stats.received_rate_histogram[1][rate_index];
3074                 }
3075
3076                 if (rate_count < priv->rate_record)
3077                         rate_count_diff = 0xffffffff - rate_count + priv->rate_record;
3078                 else
3079                         rate_count_diff = rate_count - priv->rate_record;
3080                 if (rate_count_diff < priv->rateCountDiffRecord)
3081                 {
3082
3083                         u32 DiffNum = priv->rateCountDiffRecord - rate_count_diff;
3084                         if (DiffNum >= priv->rtllib->fsync_seconddiff_ratethreshold)
3085                                 priv->ContiuneDiffCount++;
3086                         else
3087                                 priv->ContiuneDiffCount = 0;
3088
3089                         if (priv->ContiuneDiffCount >=2)
3090                         {
3091                                 bSwitchFromCountDiff = true;
3092                                 priv->ContiuneDiffCount = 0;
3093                         }
3094                 }
3095                 else
3096                 {
3097                         priv->ContiuneDiffCount = 0;
3098                 }
3099
3100                 if (rate_count_diff <= priv->rtllib->fsync_firstdiff_ratethreshold)
3101                 {
3102                         bSwitchFromCountDiff = true;
3103                         priv->ContiuneDiffCount = 0;
3104                 }
3105                 priv->rate_record = rate_count;
3106                 priv->rateCountDiffRecord = rate_count_diff;
3107                 RT_TRACE(COMP_HALDM, "rateRecord %d rateCount %d, rateCountdiff %d bSwitchFsync %d\n", priv->rate_record, rate_count, rate_count_diff , priv->bswitch_fsync);
3108                 if (priv->undecorated_smoothed_pwdb > priv->rtllib->fsync_rssi_threshold && bSwitchFromCountDiff)
3109                 {
3110                         bDoubleTimeInterval = true;
3111                         priv->bswitch_fsync = !priv->bswitch_fsync;
3112                         if (priv->bswitch_fsync)
3113                         {
3114                                 write_nic_byte(dev,0xC36, 0x1c);
3115                                 write_nic_byte(dev, 0xC3e, 0x90);
3116                         }
3117                         else
3118                         {
3119                                 write_nic_byte(dev, 0xC36, 0x5c);
3120                                 write_nic_byte(dev, 0xC3e, 0x96);
3121                         }
3122                 }
3123                 else if (priv->undecorated_smoothed_pwdb <= priv->rtllib->fsync_rssi_threshold)
3124                 {
3125                         if (priv->bswitch_fsync)
3126                         {
3127                                 priv->bswitch_fsync  = false;
3128                                 write_nic_byte(dev, 0xC36, 0x5c);
3129                                 write_nic_byte(dev, 0xC3e, 0x96);
3130                         }
3131                 }
3132                 if (bDoubleTimeInterval){
3133                         if (timer_pending(&priv->fsync_timer))
3134                                 del_timer_sync(&priv->fsync_timer);
3135                         priv->fsync_timer.expires = jiffies + MSECS(priv->rtllib->fsync_time_interval*priv->rtllib->fsync_multiple_timeinterval);
3136                         add_timer(&priv->fsync_timer);
3137                 }
3138                 else{
3139                         if (timer_pending(&priv->fsync_timer))
3140                                 del_timer_sync(&priv->fsync_timer);
3141                         priv->fsync_timer.expires = jiffies + MSECS(priv->rtllib->fsync_time_interval);
3142                         add_timer(&priv->fsync_timer);
3143                 }
3144         }
3145         else
3146         {
3147                 if (priv->bswitch_fsync)
3148                 {
3149                         priv->bswitch_fsync  = false;
3150                         write_nic_byte(dev, 0xC36, 0x5c);
3151                         write_nic_byte(dev, 0xC3e, 0x96);
3152                 }
3153                 priv->ContiuneDiffCount = 0;
3154                 write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd);
3155         }
3156         RT_TRACE(COMP_HALDM, "ContiuneDiffCount %d\n", priv->ContiuneDiffCount);
3157         RT_TRACE(COMP_HALDM, "rateRecord %d rateCount %d, rateCountdiff %d bSwitchFsync %d\n", priv->rate_record, rate_count, rate_count_diff , priv->bswitch_fsync);
3158 }
3159
3160 static void dm_StartHWFsync(struct net_device *dev)
3161 {
3162         u8 rf_timing = 0x77;
3163         struct r8192_priv *priv = rtllib_priv(dev);
3164         RT_TRACE(COMP_HALDM, "%s\n", __func__);
3165         write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c12cf);
3166         priv->rtllib->SetHwRegHandler(dev, HW_VAR_RF_TIMING, (u8*)(&rf_timing));
3167         write_nic_byte(dev, 0xc3b, 0x41);
3168 }
3169
3170 static void dm_EndHWFsync(struct net_device *dev)
3171 {
3172         u8 rf_timing = 0xaa;
3173         struct r8192_priv *priv = rtllib_priv(dev);
3174         RT_TRACE(COMP_HALDM,"%s\n", __func__);
3175         write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd);
3176         priv->rtllib->SetHwRegHandler(dev, HW_VAR_RF_TIMING, (u8*)(&rf_timing));
3177         write_nic_byte(dev, 0xc3b, 0x49);
3178 }
3179
3180 static void dm_EndSWFsync(struct net_device *dev)
3181 {
3182         struct r8192_priv *priv = rtllib_priv(dev);
3183
3184         RT_TRACE(COMP_HALDM, "%s\n", __func__);
3185         del_timer_sync(&(priv->fsync_timer));
3186
3187         if (priv->bswitch_fsync)
3188         {
3189                 priv->bswitch_fsync  = false;
3190
3191                 write_nic_byte(dev, 0xC36, 0x5c);
3192
3193                 write_nic_byte(dev, 0xC3e, 0x96);
3194         }
3195
3196         priv->ContiuneDiffCount = 0;
3197         write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd);
3198 }
3199
3200 static void dm_StartSWFsync(struct net_device *dev)
3201 {
3202         struct r8192_priv *priv = rtllib_priv(dev);
3203         u32                     rateIndex;
3204         u32                     rateBitmap;
3205
3206         RT_TRACE(COMP_HALDM,"%s\n", __func__);
3207         priv->rate_record = 0;
3208         priv->ContiuneDiffCount = 0;
3209         priv->rateCountDiffRecord = 0;
3210         priv->bswitch_fsync  = false;
3211
3212         if (priv->rtllib->mode == WIRELESS_MODE_N_24G)
3213         {
3214                 priv->rtllib->fsync_firstdiff_ratethreshold= 600;
3215                 priv->rtllib->fsync_seconddiff_ratethreshold = 0xffff;
3216         }
3217         else
3218         {
3219                 priv->rtllib->fsync_firstdiff_ratethreshold= 200;
3220                 priv->rtllib->fsync_seconddiff_ratethreshold = 200;
3221         }
3222         for (rateIndex = 0; rateIndex <= 27; rateIndex++)
3223         {
3224                 rateBitmap  = 1 << rateIndex;
3225                 if (priv->rtllib->fsync_rate_bitmap &  rateBitmap)
3226                         priv->rate_record += priv->stats.received_rate_histogram[1][rateIndex];
3227         }
3228         if (timer_pending(&priv->fsync_timer))
3229                 del_timer_sync(&priv->fsync_timer);
3230         priv->fsync_timer.expires = jiffies + MSECS(priv->rtllib->fsync_time_interval);
3231         add_timer(&priv->fsync_timer);
3232
3233         write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c12cd);
3234
3235 }
3236
3237 void dm_check_fsync(struct net_device *dev)
3238 {
3239 #define RegC38_Default                          0
3240 #define RegC38_NonFsync_Other_AP        1
3241 #define RegC38_Fsync_AP_BCM             2
3242         struct r8192_priv *priv = rtllib_priv(dev);
3243         static u8               reg_c38_State=RegC38_Default;
3244         static u32      reset_cnt=0;
3245
3246         RT_TRACE(COMP_HALDM, "RSSI %d TimeInterval %d MultipleTimeInterval %d\n", priv->rtllib->fsync_rssi_threshold, priv->rtllib->fsync_time_interval, priv->rtllib->fsync_multiple_timeinterval);
3247         RT_TRACE(COMP_HALDM, "RateBitmap 0x%x FirstDiffRateThreshold %d SecondDiffRateThreshold %d\n", priv->rtllib->fsync_rate_bitmap, priv->rtllib->fsync_firstdiff_ratethreshold, priv->rtllib->fsync_seconddiff_ratethreshold);
3248
3249         if (    priv->rtllib->state == RTLLIB_LINKED &&
3250                 priv->rtllib->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
3251         {
3252                 if (priv->rtllib->bfsync_enable == 0)
3253                 {
3254                         switch (priv->rtllib->fsync_state)
3255                         {
3256                                 case Default_Fsync:
3257                                         dm_StartHWFsync(dev);
3258                                         priv->rtllib->fsync_state = HW_Fsync;
3259                                         break;
3260                                 case SW_Fsync:
3261                                         dm_EndSWFsync(dev);
3262                                         dm_StartHWFsync(dev);
3263                                         priv->rtllib->fsync_state = HW_Fsync;
3264                                         break;
3265                                 case HW_Fsync:
3266                                 default:
3267                                         break;
3268                         }
3269                 }
3270                 else
3271                 {
3272                         switch (priv->rtllib->fsync_state)
3273                         {
3274                                 case Default_Fsync:
3275                                         dm_StartSWFsync(dev);
3276                                         priv->rtllib->fsync_state = SW_Fsync;
3277                                         break;
3278                                 case HW_Fsync:
3279                                         dm_EndHWFsync(dev);
3280                                         dm_StartSWFsync(dev);
3281                                         priv->rtllib->fsync_state = SW_Fsync;
3282                                         break;
3283                                 case SW_Fsync:
3284                                 default:
3285                                         break;
3286
3287                         }
3288                 }
3289                 if (priv->framesyncMonitor)
3290                 {
3291                         if (reg_c38_State != RegC38_Fsync_AP_BCM)
3292                         {
3293                                         write_nic_byte(dev, rOFDM0_RxDetector3, 0x95);
3294
3295                                 reg_c38_State = RegC38_Fsync_AP_BCM;
3296                         }
3297                 }
3298         } else {
3299                 switch (priv->rtllib->fsync_state) {
3300                 case HW_Fsync:
3301                         dm_EndHWFsync(dev);
3302                         priv->rtllib->fsync_state = Default_Fsync;
3303                         break;
3304                 case SW_Fsync:
3305                         dm_EndSWFsync(dev);
3306                         priv->rtllib->fsync_state = Default_Fsync;
3307                         break;
3308                 case Default_Fsync:
3309                 default:
3310                         break;
3311                 }
3312
3313                 if (priv->framesyncMonitor) {
3314                         if (priv->rtllib->state == RTLLIB_LINKED) {
3315                                 if (priv->undecorated_smoothed_pwdb <= RegC38_TH) {
3316                                         if (reg_c38_State != RegC38_NonFsync_Other_AP) {
3317                                                         write_nic_byte(dev, rOFDM0_RxDetector3, 0x90);
3318
3319                                                 reg_c38_State = RegC38_NonFsync_Other_AP;
3320                                         }
3321                                 } else if (priv->undecorated_smoothed_pwdb >= (RegC38_TH+5)) {
3322                                         if (reg_c38_State) {
3323                                                 write_nic_byte(dev, rOFDM0_RxDetector3, priv->framesync);
3324                                                 reg_c38_State = RegC38_Default;
3325                                         }
3326                                 }
3327                         } else {
3328                                 if (reg_c38_State) {
3329                                         write_nic_byte(dev, rOFDM0_RxDetector3, priv->framesync);
3330                                         reg_c38_State = RegC38_Default;
3331                                 }
3332                         }
3333                 }
3334         }
3335         if (priv->framesyncMonitor) {
3336                 if (priv->reset_count != reset_cnt) {
3337                         write_nic_byte(dev, rOFDM0_RxDetector3, priv->framesync);
3338                         reg_c38_State = RegC38_Default;
3339                         reset_cnt = priv->reset_count;
3340                 }
3341         } else {
3342                 if (reg_c38_State) {
3343                         write_nic_byte(dev, rOFDM0_RxDetector3, priv->framesync);
3344                         reg_c38_State = RegC38_Default;
3345                 }
3346         }
3347 }
3348
3349 extern void dm_shadow_init(struct net_device *dev)
3350 {
3351         u8      page;
3352         u16     offset;
3353
3354         for (page = 0; page < 5; page++)
3355                 for (offset = 0; offset < 256; offset++)
3356                         dm_shadow[page][offset] = read_nic_byte(dev, offset+page*256);
3357
3358         for (page = 8; page < 11; page++)
3359                 for (offset = 0; offset < 256; offset++)
3360                         dm_shadow[page][offset] = read_nic_byte(dev, offset+page*256);
3361
3362         for (page = 12; page < 15; page++)
3363                 for (offset = 0; offset < 256; offset++)
3364                         dm_shadow[page][offset] = read_nic_byte(dev, offset+page*256);
3365
3366 }
3367
3368 /*---------------------------Define function prototype------------------------*/
3369 static void dm_init_dynamic_txpower(struct net_device *dev)
3370 {
3371         struct r8192_priv *priv = rtllib_priv(dev);
3372
3373         priv->rtllib->bdynamic_txpower_enable = true;
3374         priv->bLastDTPFlag_High = false;
3375         priv->bLastDTPFlag_Low = false;
3376         priv->bDynamicTxHighPower = false;
3377         priv->bDynamicTxLowPower = false;
3378 }
3379
3380 static void dm_dynamic_txpower(struct net_device *dev)
3381 {
3382         struct r8192_priv *priv = rtllib_priv(dev);
3383         unsigned int txhipower_threshhold=0;
3384         unsigned int txlowpower_threshold=0;
3385         if (priv->rtllib->bdynamic_txpower_enable != true)
3386         {
3387                 priv->bDynamicTxHighPower = false;
3388                 priv->bDynamicTxLowPower = false;
3389                 return;
3390         }
3391         if ((priv->rtllib->pHTInfo->IOTPeer == HT_IOT_PEER_ATHEROS) && (priv->rtllib->mode == IEEE_G)){
3392                 txhipower_threshhold = TX_POWER_ATHEROAP_THRESH_HIGH;
3393                 txlowpower_threshold = TX_POWER_ATHEROAP_THRESH_LOW;
3394         }
3395         else
3396         {
3397                 txhipower_threshhold = TX_POWER_NEAR_FIELD_THRESH_HIGH;
3398                 txlowpower_threshold = TX_POWER_NEAR_FIELD_THRESH_LOW;
3399         }
3400
3401
3402         RT_TRACE(COMP_TXAGC,"priv->undecorated_smoothed_pwdb = %ld \n" , priv->undecorated_smoothed_pwdb);
3403
3404         if (priv->rtllib->state == RTLLIB_LINKED)
3405         {
3406                 if (priv->undecorated_smoothed_pwdb >= txhipower_threshhold)
3407                 {
3408                         priv->bDynamicTxHighPower = true;
3409                         priv->bDynamicTxLowPower = false;
3410                 }
3411                 else
3412                 {
3413                         if (priv->undecorated_smoothed_pwdb < txlowpower_threshold && priv->bDynamicTxHighPower == true)
3414                         {
3415                                 priv->bDynamicTxHighPower = false;
3416                         }
3417                         if (priv->undecorated_smoothed_pwdb < 35)
3418                         {
3419                                 priv->bDynamicTxLowPower = true;
3420                         }
3421                         else if (priv->undecorated_smoothed_pwdb >= 40)
3422                         {
3423                                 priv->bDynamicTxLowPower = false;
3424                         }
3425                 }
3426         }
3427         else
3428         {
3429                 priv->bDynamicTxHighPower = false;
3430                 priv->bDynamicTxLowPower = false;
3431         }
3432
3433         if ( (priv->bDynamicTxHighPower != priv->bLastDTPFlag_High ) ||
3434                 (priv->bDynamicTxLowPower != priv->bLastDTPFlag_Low ) )
3435         {
3436                 RT_TRACE(COMP_TXAGC,"SetTxPowerLevel8190()  channel = %d \n" , priv->rtllib->current_network.channel);
3437
3438                 rtl8192_phy_setTxPower(dev,priv->rtllib->current_network.channel);
3439         }
3440         priv->bLastDTPFlag_High = priv->bDynamicTxHighPower;
3441         priv->bLastDTPFlag_Low = priv->bDynamicTxLowPower;
3442
3443 }
3444
3445 static void dm_check_txrateandretrycount(struct net_device * dev)
3446 {
3447         struct r8192_priv *priv = rtllib_priv(dev);
3448         struct rtllib_device* ieee = priv->rtllib;
3449
3450         ieee->softmac_stats.CurrentShowTxate = read_nic_byte(dev, Current_Tx_Rate_Reg);
3451
3452         ieee->softmac_stats.last_packet_rate = read_nic_byte(dev ,Initial_Tx_Rate_Reg);
3453
3454         ieee->softmac_stats.txretrycount = read_nic_dword(dev, Tx_Retry_Count_Reg);
3455 }
3456
3457 static void dm_send_rssi_tofw(struct net_device *dev)
3458 {
3459         struct dcmd_txcmd tx_cmd;
3460         struct r8192_priv *priv = rtllib_priv(dev);
3461
3462         write_nic_byte(dev, DRIVER_RSSI, (u8)priv->undecorated_smoothed_pwdb);
3463         return;
3464         tx_cmd.Op               = TXCMD_SET_RX_RSSI;
3465         tx_cmd.Length   = 4;
3466         tx_cmd.Value            = priv->undecorated_smoothed_pwdb;
3467
3468         cmpk_message_handle_tx(dev, (u8*)&tx_cmd,
3469                                                                 DESC_PACKET_TYPE_INIT, sizeof(struct dcmd_txcmd));
3470 }
3471
3472 /*---------------------------Define function prototype------------------------*/