drivers/staging/rtl8821ae/rtl8821ae/hal_bt_coexist.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2009-2010  Realtek Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  * The full GNU General Public License is included in this distribution in the
  19  * file called LICENSE.
  20  *
  21  * Contact Information:
  22  * wlanfae <wlanfae@realtek.com>
  23  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  24  * Hsinchu 300, Taiwan.
  25  *
  26  * Larry Finger <Larry.Finger@lwfinger.net>
  27  *
  28  *****************************************************************************/
  29
  30 #include "hal_bt_coexist.h"
  31 #include "../pci.h"
  32 #include "dm.h"
  33 #include "fw.h"
  34 #include "phy.h"
  35 #include "reg.h"
  36 #include "hal_btc.h"
  37
  38 static bool bt_operation_on = false;
  39
  40 void rtl8821ae_dm_bt_reject_ap_aggregated_packet(struct ieee80211_hw *hw, bool b_reject)
  41 {
  42 #if 0
  43         struct rtl_priv rtlpriv = rtl_priv(hw);
  44         PRX_TS_RECORD                   pRxTs = NULL;
  45
  46         if(b_reject){
  47                 // Do not allow receiving A-MPDU aggregation.
  48                 if (rtlpriv->mac80211.vendor == PEER_CISCO) {
  49                                 if (pHTInfo->bAcceptAddbaReq) {
  50                                         RTPRINT(FBT, BT_TRACE, ("BT_Disallow AMPDU \n"));
  51                                         pHTInfo->bAcceptAddbaReq = FALSE;
  52                                         if(GetTs(Adapter, (PTS_COMMON_INFO*)(&pRxTs), pMgntInfo->Bssid, 0, RX_DIR, FALSE))
  53                                                 TsInitDelBA(Adapter, (PTS_COMMON_INFO)pRxTs, RX_DIR);
  54                                 }
  55                         } else {
  56                                 if (!pHTInfo->bAcceptAddbaReq) {
  57                                         RTPRINT(FBT, BT_TRACE, ("BT_Allow AMPDU BT Idle\n"));
  58                                         pHTInfo->bAcceptAddbaReq = TRUE;
  59                                 }
  60                         }
  61                 } else {
  62                         if(rtlpriv->mac80211.vendor == PEER_CISCO) {
  63                                 if (!pHTInfo->bAcceptAddbaReq) {
  64                                         RTPRINT(FBT, BT_TRACE, ("BT_Allow AMPDU \n"));
  65                                         pHTInfo->bAcceptAddbaReq = TRUE;
  66                                 }
  67                         }
  68                 }
  69 #endif
  70 }
  71
  72 void _rtl8821ae_dm_bt_check_wifi_state(struct ieee80211_hw *hw)
  73 {
  74 struct rtl_priv *rtlpriv = rtl_priv(hw);
  75 struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
  76 struct rtl_phy *rtlphy = &(rtlpriv->phy);
  77
  78 if (rtlpriv->link_info.b_busytraffic) {
  79         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_IDLE;
  80
  81         if(rtlpriv->link_info.b_tx_busy_traffic) {
  82                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_UPLINK;
  83         } else {
  84                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_UPLINK;
  85         }
  86
  87         if(rtlpriv->link_info.b_rx_busy_traffic) {
  88                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_DOWNLINK;
  89         } else {
  90                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_DOWNLINK;
  91         }
  92 } else {
  93         rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_IDLE;
  94         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_UPLINK;
  95         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_DOWNLINK;
  96 }
  97
  98 if (rtlpriv->mac80211.mode == WIRELESS_MODE_G
  99         || rtlpriv->mac80211.mode == WIRELESS_MODE_B) {
 100         rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_LEGACY;
 101         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_HT20;
 102         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_HT40;
 103 } else {
 104         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_LEGACY;
 105         if(rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) {
 106                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_HT40;
 107                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_HT20;
 108         } else {
 109                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_HT20;
 110                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_HT40;
 111         }
 112 }
 113
 114 if (bt_operation_on) {
 115         rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_BT30;
 116 } else {
 117         rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_BT30;
 118 }
 119 }
 120
 121
 122 u8 rtl8821ae_dm_bt_check_coex_rssi_state1(struct ieee80211_hw *hw,
 123                                                 u8      level_num, u8   rssi_thresh, u8 rssi_thresh1)
 124
 125 {
 126         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 127         struct rtl_priv *rtlpriv = rtl_priv(hw);
 128         long undecoratedsmoothed_pwdb = 0;
 129         u8 bt_rssi_state = 0;
 130
 131         undecoratedsmoothed_pwdb =  rtl8821ae_dm_bt_get_rx_ss(hw);
 132
 133         if(level_num == 2) {
 134                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
 135
 136                 if( (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_LOW) ||
 137                         (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_STAY_LOW)) {
 138                         if(undecoratedsmoothed_pwdb >= (rssi_thresh + BT_FW_COEX_THRESH_TOL)) {
 139                                 bt_rssi_state = BT_RSSI_STATE_HIGH;
 140                                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
 141                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
 142                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
 143                         } else {
 144                                 bt_rssi_state = BT_RSSI_STATE_STAY_LOW;
 145                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
 146                         }
 147                 } else {
 148                         if(undecoratedsmoothed_pwdb < rssi_thresh) {
 149                                 bt_rssi_state = BT_RSSI_STATE_LOW;
 150                                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
 151                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
 152                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
 153                         } else {
 154                                 bt_rssi_state = BT_RSSI_STATE_STAY_HIGH;
 155                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
 156                         }
 157                 }
 158         } else if(level_num == 3) {
 159                 if(rssi_thresh > rssi_thresh1) {
 160                         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 thresh error!!\n"));
 161                         return rtlpcipriv->btcoexist.bt_pre_rssi_state;
 162                 }
 163
 164                 if( (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_LOW) ||
 165                         (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_STAY_LOW)) {
 166                         if(undecoratedsmoothed_pwdb >= (rssi_thresh+BT_FW_COEX_THRESH_TOL)) {
 167                                 bt_rssi_state = BT_RSSI_STATE_MEDIUM;
 168                                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
 169                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
 170                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
 171                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
 172                         } else {
 173                                 bt_rssi_state = BT_RSSI_STATE_STAY_LOW;
 174                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
 175                         }
 176                 } else if( (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_MEDIUM) ||
 177                         (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_STAY_MEDIUM)) {
 178                         if(undecoratedsmoothed_pwdb >= (rssi_thresh1 + BT_FW_COEX_THRESH_TOL)) {
 179                                 bt_rssi_state = BT_RSSI_STATE_HIGH;
 180                                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
 181                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
 182                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
 183                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
 184                         } else if(undecoratedsmoothed_pwdb < rssi_thresh) {
 185                                 bt_rssi_state = BT_RSSI_STATE_LOW;
 186                                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
 187                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
 188                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
 189                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
 190                         } else {
 191                                 bt_rssi_state = BT_RSSI_STATE_STAY_MEDIUM;
 192                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state stay at Medium\n"));
 193                         }
 194                 } else {
 195                         if(undecoratedsmoothed_pwdb < rssi_thresh1) {
 196                                 bt_rssi_state = BT_RSSI_STATE_MEDIUM;
 197                                 rtlpcipriv->btcoexist.current_state |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
 198                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
 199                                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
 200                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,("[DM][BT], RSSI_1 state switch to Medium\n"));
 201                         } else {
 202                                 bt_rssi_state = BT_RSSI_STATE_STAY_HIGH;
 203                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
 204                         }
 205                 }
 206         }
 207
 208         rtlpcipriv->btcoexist.bt_pre_rssi_state1 = bt_rssi_state;
 209
 210         return bt_rssi_state;
 211 }
 212
 213 u8 rtl8821ae_dm_bt_check_coex_rssi_state(struct ieee80211_hw *hw,
 214                                                 u8      level_num, u8   rssi_thresh, u8 rssi_thresh1)
 215 {
 216         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 217         struct rtl_priv *rtlpriv = rtl_priv(hw);
 218         long undecoratedsmoothed_pwdb = 0;
 219         u8 bt_rssi_state = 0;
 220
 221         undecoratedsmoothed_pwdb = rtl8821ae_dm_bt_get_rx_ss(hw);
 222
 223         if (level_num == 2) {
 224                 rtlpcipriv->btcoexist.current_state &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
 225
 226                 if ((rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_LOW) ||
 227                         (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_STAY_LOW)){
 228                         if (undecoratedsmoothed_pwdb
 229                                 >= (rssi_thresh + BT_FW_COEX_THRESH_TOL)) {
 230                                 bt_rssi_state = BT_RSSI_STATE_HIGH;
 231                                 rtlpcipriv->btcoexist.current_state
 232                                         |= BT_COEX_STATE_WIFI_RSSI_HIGH;
 233                                 rtlpcipriv->btcoexist.current_state
 234                                         &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
 235                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 236                                         ("[DM][BT], RSSI state switch to High\n"));
 237                         } else {
 238                                 bt_rssi_state = BT_RSSI_STATE_STAY_LOW;
 239                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 240                                         ("[DM][BT], RSSI state stay at Low\n"));
 241                         }
 242                 } else {
 243                         if (undecoratedsmoothed_pwdb < rssi_thresh) {
 244                                 bt_rssi_state = BT_RSSI_STATE_LOW;
 245                                 rtlpcipriv->btcoexist.current_state
 246                                         |= BT_COEX_STATE_WIFI_RSSI_LOW;
 247                                 rtlpcipriv->btcoexist.current_state
 248                                         &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
 249                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 250                                         ("[DM][BT], RSSI state switch to Low\n"));
 251                         } else {
 252                                 bt_rssi_state = BT_RSSI_STATE_STAY_HIGH;
 253                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 254                                         ("[DM][BT], RSSI state stay at High\n"));
 255                         }
 256                 }
 257         }
 258         else if (level_num == 3) {
 259                 if (rssi_thresh > rssi_thresh1) {
 260                         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 261                                 ("[DM][BT], RSSI thresh error!!\n"));
 262                         return rtlpcipriv->btcoexist.bt_pre_rssi_state;
 263                 }
 264                 if ((rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_LOW) ||
 265                         (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_STAY_LOW)) {
 266                         if(undecoratedsmoothed_pwdb
 267                                 >= (rssi_thresh + BT_FW_COEX_THRESH_TOL)) {
 268                                 bt_rssi_state = BT_RSSI_STATE_MEDIUM;
 269                                 rtlpcipriv->btcoexist.current_state
 270                                         |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
 271                                 rtlpcipriv->btcoexist.current_state
 272                                         &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
 273                                 rtlpcipriv->btcoexist.current_state
 274                                         &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
 275                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 276                                         ("[DM][BT], RSSI state switch to Medium\n"));
 277                         } else {
 278                                 bt_rssi_state = BT_RSSI_STATE_STAY_LOW;
 279                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 280                                         ("[DM][BT], RSSI state stay at Low\n"));
 281                         }
 282                 } else if ((rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_MEDIUM) ||
 283                         (rtlpcipriv->btcoexist.bt_pre_rssi_state == BT_RSSI_STATE_STAY_MEDIUM)) {
 284                         if (undecoratedsmoothed_pwdb
 285                                 >= (rssi_thresh1 + BT_FW_COEX_THRESH_TOL)) {
 286                                 bt_rssi_state = BT_RSSI_STATE_HIGH;
 287                                 rtlpcipriv->btcoexist.current_state
 288                                         |= BT_COEX_STATE_WIFI_RSSI_HIGH;
 289                                 rtlpcipriv->btcoexist.current_state
 290                                         &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
 291                                 rtlpcipriv->btcoexist.current_state
 292                                         &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
 293                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 294                                         ("[DM][BT], RSSI state switch to High\n"));
 295                         } else if(undecoratedsmoothed_pwdb < rssi_thresh)
 296                         {
 297                                 bt_rssi_state = BT_RSSI_STATE_LOW;
 298                                 rtlpcipriv->btcoexist.current_state
 299                                         |= BT_COEX_STATE_WIFI_RSSI_LOW;
 300                                 rtlpcipriv->btcoexist.current_state
 301                                         &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
 302                                 rtlpcipriv->btcoexist.current_state
 303                                         &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
 304                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 305                                         ("[DM][BT], RSSI state switch to Low\n"));
 306                         } else {
 307                                 bt_rssi_state = BT_RSSI_STATE_STAY_MEDIUM;
 308                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 309                                         ("[DM][BT], RSSI state stay at Medium\n"));
 310                         }
 311                 } else {
 312                         if(undecoratedsmoothed_pwdb < rssi_thresh1) {
 313                                 bt_rssi_state = BT_RSSI_STATE_MEDIUM;
 314                                 rtlpcipriv->btcoexist.current_state
 315                                         |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
 316                                 rtlpcipriv->btcoexist.current_state
 317                                         &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
 318                                 rtlpcipriv->btcoexist.current_state
 319                                         &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
 320                                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 321                                         ("[DM][BT], RSSI state switch to Medium\n"));
 322                         } else {
 323                         bt_rssi_state = BT_RSSI_STATE_STAY_HIGH;
 324                         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 325                                 ("[DM][BT], RSSI state stay at High\n"));
 326                         }
 327                 }
 328         }
 329
 330         rtlpcipriv->btcoexist.bt_pre_rssi_state = bt_rssi_state;
 331         return bt_rssi_state;
 332 }
 333 long rtl8821ae_dm_bt_get_rx_ss(struct ieee80211_hw *hw)
 334 {
 335         struct rtl_priv *rtlpriv = rtl_priv(hw);
 336         long undecoratedsmoothed_pwdb = 0;
 337
 338         if (rtlpriv->mac80211.link_state >= MAC80211_LINKED) {
 339                 undecoratedsmoothed_pwdb = GET_UNDECORATED_AVERAGE_RSSI(rtlpriv);
 340         } else {
 341                 undecoratedsmoothed_pwdb
 342                         = rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb;
 343         }
 344         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 345                 ("rtl8821ae_dm_bt_get_rx_ss() = %ld\n", undecoratedsmoothed_pwdb));
 346
 347         return undecoratedsmoothed_pwdb;
 348 }
 349
 350 void rtl8821ae_dm_bt_balance(struct ieee80211_hw *hw,
 351                                                         bool b_balance_on, u8 ms0, u8 ms1)
 352 {
 353         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 354         struct rtl_priv *rtlpriv = rtl_priv(hw);
 355         u8 h2c_parameter[3] ={0};
 356
 357         if (b_balance_on) {
 358                 h2c_parameter[2] = 1;
 359                 h2c_parameter[1] = ms1;
 360                 h2c_parameter[0] = ms0;
 361                 rtlpcipriv->btcoexist.b_fw_coexist_all_off = false;
 362         } else {
 363                 h2c_parameter[2] = 0;
 364                 h2c_parameter[1] = 0;
 365                 h2c_parameter[0] = 0;
 366         }
 367         rtlpcipriv->btcoexist.b_balance_on = b_balance_on;
 368
 369         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 370                 ("[DM][BT], Balance=[%s:%dms:%dms], write 0xc=0x%x\n",
 371                 b_balance_on?"ON":"OFF", ms0, ms1,
 372                 h2c_parameter[0]<<16 | h2c_parameter[1]<<8 | h2c_parameter[2]));
 373
 374         rtl8821ae_fill_h2c_cmd(hw, 0xc, 3, h2c_parameter);
 375 }
 376
 377
 378 void rtl8821ae_dm_bt_agc_table(struct ieee80211_hw *hw, u8 type)
 379 {
 380         struct rtl_priv *rtlpriv = rtl_priv(hw);
 381         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 382
 383         if (type == BT_AGCTABLE_OFF) {
 384                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[BT]AGCTable Off!\n"));
 385                 rtl_write_dword(rtlpriv, 0xc78,0x641c0001);
 386                 rtl_write_dword(rtlpriv, 0xc78,0x631d0001);
 387                 rtl_write_dword(rtlpriv, 0xc78,0x621e0001);
 388                 rtl_write_dword(rtlpriv, 0xc78,0x611f0001);
 389                 rtl_write_dword(rtlpriv, 0xc78,0x60200001);
 390
 391                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 392                                         RF_RX_AGC_HP, 0xfffff, 0x32000);
 393                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 394                                         RF_RX_AGC_HP, 0xfffff, 0x71000);
 395                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 396                                         RF_RX_AGC_HP, 0xfffff, 0xb0000);
 397                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 398                                         RF_RX_AGC_HP, 0xfffff, 0xfc000);
 399                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 400                                         RF_RX_G1, 0xfffff, 0x30355);
 401         } else if (type == BT_AGCTABLE_ON) {
 402                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[BT]AGCTable On!\n"));
 403                 rtl_write_dword(rtlpriv, 0xc78,0x4e1c0001);
 404                 rtl_write_dword(rtlpriv, 0xc78,0x4d1d0001);
 405                 rtl_write_dword(rtlpriv, 0xc78,0x4c1e0001);
 406                 rtl_write_dword(rtlpriv, 0xc78,0x4b1f0001);
 407                 rtl_write_dword(rtlpriv, 0xc78,0x4a200001);
 408
 409                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 410                                         RF_RX_AGC_HP, 0xfffff, 0xdc000);
 411                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 412                                         RF_RX_AGC_HP, 0xfffff, 0x90000);
 413                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 414                                         RF_RX_AGC_HP, 0xfffff, 0x51000);
 415                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 416                                         RF_RX_AGC_HP, 0xfffff, 0x12000);
 417                 rtl8821ae_phy_set_rf_reg(hw, RF90_PATH_A,
 418                                         RF_RX_G1, 0xfffff, 0x00355);
 419
 420                 rtlpcipriv->btcoexist.b_sw_coexist_all_off = false;
 421         }
 422 }
 423
 424 void rtl8821ae_dm_bt_bb_back_off_level(struct ieee80211_hw *hw, u8 type)
 425 {
 426         struct rtl_priv *rtlpriv = rtl_priv(hw);
 427         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 428
 429         if (type == BT_BB_BACKOFF_OFF) {
 430                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[BT]BBBackOffLevel Off!\n"));
 431                 rtl_write_dword(rtlpriv, 0xc04,0x3a05611);
 432         } else if (type == BT_BB_BACKOFF_ON) {
 433                 RT_TRACE(COMP_BT_COEXIST, DBG_TRACE, ("[BT]BBBackOffLevel On!\n"));
 434                 rtl_write_dword(rtlpriv, 0xc04,0x3a07611);
 435                 rtlpcipriv->btcoexist.b_sw_coexist_all_off = false;
 436         }
 437 }
 438
 439 void rtl8821ae_dm_bt_fw_coex_all_off(struct ieee80211_hw *hw)
 440 {
 441         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 442         struct rtl_priv *rtlpriv = rtl_priv(hw);
 443         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 444                 ("rtl8821ae_dm_bt_fw_coex_all_off()\n"));
 445
 446         if(rtlpcipriv->btcoexist.b_fw_coexist_all_off)
 447                 return;
 448
 449         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 450                 ("rtl8821ae_dm_bt_fw_coex_all_off(), real Do\n"));
 451         rtl8821ae_dm_bt_fw_coex_all_off_8723a(hw);
 452         rtlpcipriv->btcoexist.b_fw_coexist_all_off = true;
 453 }
 454
 455 void rtl8821ae_dm_bt_sw_coex_all_off(struct ieee80211_hw *hw)
 456 {
 457         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 458         struct rtl_priv *rtlpriv = rtl_priv(hw);
 459
 460         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 461                 ("rtl8821ae_dm_bt_sw_coex_all_off()\n"));
 462
 463         if(rtlpcipriv->btcoexist.b_sw_coexist_all_off)
 464                 return;
 465
 466         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 467                 ("rtl8821ae_dm_bt_sw_coex_all_off(), real Do\n"));
 468         rtl8821ae_dm_bt_sw_coex_all_off_8723a(hw);
 469         rtlpcipriv->btcoexist.b_sw_coexist_all_off = true;
 470 }
 471
 472 void rtl8821ae_dm_bt_hw_coex_all_off(struct ieee80211_hw *hw)
 473 {
 474         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 475         struct rtl_priv *rtlpriv = rtl_priv(hw);
 476
 477         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 478                 ("rtl8821ae_dm_bt_hw_coex_all_off()\n"));
 479
 480         if(rtlpcipriv->btcoexist.b_hw_coexist_all_off)
 481                 return;
 482         RT_TRACE(COMP_BT_COEXIST, DBG_TRACE,
 483                 ("rtl8821ae_dm_bt_hw_coex_all_off(), real Do\n"));
 484
 485         rtl8821ae_dm_bt_hw_coex_all_off_8723a(hw);
 486
 487         rtlpcipriv->btcoexist.b_hw_coexist_all_off = true;
 488 }
 489
 490 void rtl8821ae_btdm_coex_all_off(struct ieee80211_hw *hw)
 491 {
 492         rtl8821ae_dm_bt_fw_coex_all_off(hw);
 493         rtl8821ae_dm_bt_sw_coex_all_off(hw);
 494         rtl8821ae_dm_bt_hw_coex_all_off(hw);
 495 }
 496
 497 bool rtl8821ae_dm_bt_is_coexist_state_changed(struct ieee80211_hw *hw)
 498 {
 499         struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
 500
 501         if((rtlpcipriv->btcoexist.previous_state
 502                 == rtlpcipriv->btcoexist.current_state)
 503                 && (rtlpcipriv->btcoexist.previous_state_h
 504                 == rtlpcipriv->btcoexist.current_state_h))
 505                 return false;
 506         else
 507                 return true;
 508 }
 509
 510 bool rtl8821ae_dm_bt_is_wifi_up_link(struct ieee80211_hw *hw)
 511 {
 512         struct rtl_priv *rtlpriv = rtl_priv(hw);
 513
 514         if (rtlpriv->link_info.b_tx_busy_traffic)
 515                 return true;
 516         else
 517                 return false;
 518 }
 519