drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b2ant.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2012  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  * The full GNU General Public License is included in this distribution in the
  15  * file called LICENSE.
  16  *
  17  * Contact Information:
  18  * wlanfae <wlanfae@realtek.com>
  19  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  20  * Hsinchu 300, Taiwan.
  21  *
  22  * Larry Finger <Larry.Finger@lwfinger.net>
  23  *
  24  *****************************************************************************/
  25 /***************************************************************
  26  * Description:
  27  *
  28  * This file is for RTL8723B Co-exist mechanism
  29  *
  30  * History
  31  * 2012/11/15 Cosa first check in.
  32  *
  33  **************************************************************/
  34 /**************************************************************
  35  * include files
  36  **************************************************************/
  37 #include "halbt_precomp.h"
  38 /**************************************************************
  39  * Global variables, these are static variables
  40  **************************************************************/
  41 static struct coex_dm_8723b_2ant glcoex_dm_8723b_2ant;
  42 static struct coex_dm_8723b_2ant *coex_dm = &glcoex_dm_8723b_2ant;
  43 static struct coex_sta_8723b_2ant glcoex_sta_8723b_2ant;
  44 static struct coex_sta_8723b_2ant *coex_sta = &glcoex_sta_8723b_2ant;
  45
  46 static const char *const glbt_info_src_8723b_2ant[] = {
  47         "BT Info[wifi fw]",
  48         "BT Info[bt rsp]",
  49         "BT Info[bt auto report]",
  50 };
  51
  52 static u32 glcoex_ver_date_8723b_2ant = 20131113;
  53 static u32 glcoex_ver_8723b_2ant = 0x3f;
  54
  55 /**************************************************************
  56  * local function proto type if needed
  57  **************************************************************/
  58 /**************************************************************
  59  * local function start with btc8723b2ant_
  60  **************************************************************/
  61 static u8 btc8723b2ant_bt_rssi_state(struct btc_coexist *btcoexist,
  62                                      u8 level_num, u8 rssi_thresh,
  63                                      u8 rssi_thresh1)
  64 {
  65         struct rtl_priv *rtlpriv = btcoexist->adapter;
  66         s32 bt_rssi = 0;
  67         u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
  68
  69         bt_rssi = coex_sta->bt_rssi;
  70
  71         if (level_num == 2) {
  72                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  73                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  74                         if (bt_rssi >= rssi_thresh +
  75                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
  76                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
  77                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  78                                          "[BTCoex], BT Rssi state switch to High\n");
  79                         } else {
  80                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  81                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  82                                          "[BTCoex], BT Rssi state stay at Low\n");
  83                         }
  84                 } else {
  85                         if (bt_rssi < rssi_thresh) {
  86                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
  87                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  88                                          "[BTCoex], BT Rssi state switch to Low\n");
  89                         } else {
  90                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
  91                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  92                                          "[BTCoex], BT Rssi state stay at High\n");
  93                         }
  94                 }
  95         } else if (level_num == 3) {
  96                 if (rssi_thresh > rssi_thresh1) {
  97                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  98                                  "[BTCoex], BT Rssi thresh error!!\n");
  99                         return coex_sta->pre_bt_rssi_state;
 100                 }
 101
 102                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
 103                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 104                         if (bt_rssi >= rssi_thresh +
 105                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 106                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 107                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 108                                          "[BTCoex], BT Rssi state switch to Medium\n");
 109                         } else {
 110                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 111                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 112                                          "[BTCoex], BT Rssi state stay at Low\n");
 113                         }
 114                 } else if ((coex_sta->pre_bt_rssi_state ==
 115                                                 BTC_RSSI_STATE_MEDIUM) ||
 116                            (coex_sta->pre_bt_rssi_state ==
 117                                                 BTC_RSSI_STATE_STAY_MEDIUM)) {
 118                         if (bt_rssi >= rssi_thresh1 +
 119                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 120                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
 121                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 122                                          "[BTCoex], BT Rssi state switch to High\n");
 123                         } else if (bt_rssi < rssi_thresh) {
 124                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
 125                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 126                                          "[BTCoex], BT Rssi state switch to Low\n");
 127                         } else {
 128                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 129                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 130                                          "[BTCoex], BT Rssi state stay at Medium\n");
 131                         }
 132                 } else {
 133                         if (bt_rssi < rssi_thresh1) {
 134                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 135                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 136                                          "[BTCoex], BT Rssi state switch to Medium\n");
 137                         } else {
 138                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 139                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 140                                          "[BTCoex], BT Rssi state stay at High\n");
 141                         }
 142                 }
 143         }
 144
 145         coex_sta->pre_bt_rssi_state = bt_rssi_state;
 146
 147         return bt_rssi_state;
 148 }
 149
 150 static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
 151                                        u8 index, u8 level_num,
 152                                        u8 rssi_thresh, u8 rssi_thresh1)
 153 {
 154         struct rtl_priv *rtlpriv = btcoexist->adapter;
 155         s32 wifi_rssi = 0;
 156         u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
 157
 158         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 159
 160         if (level_num == 2) {
 161                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 162                                                 BTC_RSSI_STATE_LOW) ||
 163                     (coex_sta->pre_wifi_rssi_state[index] ==
 164                                                 BTC_RSSI_STATE_STAY_LOW)) {
 165                         if (wifi_rssi >= rssi_thresh +
 166                                          BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 167                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 168                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 169                                          "[BTCoex], wifi RSSI state switch to High\n");
 170                         } else {
 171                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 172                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 173                                          "[BTCoex], wifi RSSI state stay at Low\n");
 174                         }
 175                 } else {
 176                         if (wifi_rssi < rssi_thresh) {
 177                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 178                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 179                                          "[BTCoex], wifi RSSI state switch to Low\n");
 180                         } else {
 181                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 182                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 183                                          "[BTCoex], wifi RSSI state stay at High\n");
 184                         }
 185                 }
 186         } else if (level_num == 3) {
 187                 if (rssi_thresh > rssi_thresh1) {
 188                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 189                                  "[BTCoex], wifi RSSI thresh error!!\n");
 190                         return coex_sta->pre_wifi_rssi_state[index];
 191                 }
 192
 193                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 194                                                 BTC_RSSI_STATE_LOW) ||
 195                     (coex_sta->pre_wifi_rssi_state[index] ==
 196                                                 BTC_RSSI_STATE_STAY_LOW)) {
 197                         if (wifi_rssi >= rssi_thresh +
 198                                         BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 199                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 200                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 201                                          "[BTCoex], wifi RSSI state switch to Medium\n");
 202                         } else {
 203                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 204                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 205                                          "[BTCoex], wifi RSSI state stay at Low\n");
 206                         }
 207                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
 208                                                 BTC_RSSI_STATE_MEDIUM) ||
 209                            (coex_sta->pre_wifi_rssi_state[index] ==
 210                                                 BTC_RSSI_STATE_STAY_MEDIUM)) {
 211                         if (wifi_rssi >= rssi_thresh1 +
 212                                          BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 213                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 214                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 215                                          "[BTCoex], wifi RSSI state switch to High\n");
 216                         } else if (wifi_rssi < rssi_thresh) {
 217                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 218                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 219                                          "[BTCoex], wifi RSSI state switch to Low\n");
 220                         } else {
 221                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 222                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 223                                          "[BTCoex], wifi RSSI state stay at Medium\n");
 224                         }
 225                 } else {
 226                         if (wifi_rssi < rssi_thresh1) {
 227                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 228                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 229                                          "[BTCoex], wifi RSSI state switch to Medium\n");
 230                         } else {
 231                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 232                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 233                                          "[BTCoex], wifi RSSI state stay at High\n");
 234                         }
 235                 }
 236         }
 237
 238         coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
 239
 240         return wifi_rssi_state;
 241 }
 242
 243 static
 244 void btc8723b2ant_limited_rx(struct btc_coexist *btcoexist, bool force_exec,
 245                              bool rej_ap_agg_pkt, bool bt_ctrl_agg_buf_size,
 246                              u8 agg_buf_size)
 247 {
 248         bool reject_rx_agg = rej_ap_agg_pkt;
 249         bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
 250         u8 rx_agg_size = agg_buf_size;
 251
 252         /* ============================================ */
 253         /*      Rx Aggregation related setting          */
 254         /* ============================================ */
 255         btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
 256                            &reject_rx_agg);
 257         /* decide BT control aggregation buf size or not */
 258         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
 259                            &bt_ctrl_rx_agg_size);
 260         /* aggregate buf size, only work when BT control Rx aggregate size */
 261         btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
 262         /* real update aggregation setting */
 263         btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 264 }
 265
 266 static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
 267 {
 268         struct rtl_priv *rtlpriv = btcoexist->adapter;
 269         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 270         u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
 271         u32 reg_hp_tx = 0, reg_hp_rx = 0;
 272         u32 reg_lp_tx = 0, reg_lp_rx = 0;
 273
 274         reg_hp_txrx = 0x770;
 275         reg_lp_txrx = 0x774;
 276
 277         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
 278         reg_hp_tx = u32tmp & MASKLWORD;
 279         reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
 280
 281         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
 282         reg_lp_tx = u32tmp & MASKLWORD;
 283         reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
 284
 285         coex_sta->high_priority_tx = reg_hp_tx;
 286         coex_sta->high_priority_rx = reg_hp_rx;
 287         coex_sta->low_priority_tx = reg_lp_tx;
 288         coex_sta->low_priority_rx = reg_lp_rx;
 289
 290         if ((coex_sta->low_priority_tx > 1050) &&
 291             (!coex_sta->c2h_bt_inquiry_page))
 292                 coex_sta->pop_event_cnt++;
 293
 294         if ((coex_sta->low_priority_rx >= 950) &&
 295             (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
 296             (!coex_sta->under_ips))
 297                 bt_link_info->slave_role = true;
 298         else
 299                 bt_link_info->slave_role = false;
 300
 301         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 302                  "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
 303                  reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
 304         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 305                  "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
 306                  reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 307
 308         /* reset counter */
 309         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 310 }
 311
 312 static void btc8723b2ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
 313 {
 314         if (coex_sta->under_ips) {
 315                 coex_sta->crc_ok_cck = 0;
 316                 coex_sta->crc_ok_11g = 0;
 317                 coex_sta->crc_ok_11n = 0;
 318                 coex_sta->crc_ok_11n_agg = 0;
 319
 320                 coex_sta->crc_err_cck = 0;
 321                 coex_sta->crc_err_11g = 0;
 322                 coex_sta->crc_err_11n = 0;
 323                 coex_sta->crc_err_11n_agg = 0;
 324         } else {
 325                 coex_sta->crc_ok_cck =
 326                         btcoexist->btc_read_4byte(btcoexist, 0xf88);
 327                 coex_sta->crc_ok_11g =
 328                         btcoexist->btc_read_2byte(btcoexist, 0xf94);
 329                 coex_sta->crc_ok_11n =
 330                         btcoexist->btc_read_2byte(btcoexist, 0xf90);
 331                 coex_sta->crc_ok_11n_agg =
 332                         btcoexist->btc_read_2byte(btcoexist, 0xfb8);
 333
 334                 coex_sta->crc_err_cck =
 335                         btcoexist->btc_read_4byte(btcoexist, 0xf84);
 336                 coex_sta->crc_err_11g =
 337                         btcoexist->btc_read_2byte(btcoexist, 0xf96);
 338                 coex_sta->crc_err_11n =
 339                         btcoexist->btc_read_2byte(btcoexist, 0xf92);
 340                 coex_sta->crc_err_11n_agg =
 341                         btcoexist->btc_read_2byte(btcoexist, 0xfba);
 342         }
 343
 344         /* reset counter */
 345         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
 346         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
 347 }
 348
 349 static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist)
 350 {
 351         struct rtl_priv *rtlpriv = btcoexist->adapter;
 352         u8 h2c_parameter[1] = {0};
 353
 354         coex_sta->c2h_bt_info_req_sent = true;
 355
 356         h2c_parameter[0] |= BIT0;       /* trigger */
 357
 358         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 359                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
 360                  h2c_parameter[0]);
 361
 362         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 363 }
 364
 365 static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
 366 {
 367         static bool pre_wifi_busy;
 368         static bool pre_under_4way;
 369         static bool pre_bt_hs_on;
 370         bool wifi_busy = false, under_4way = false, bt_hs_on = false;
 371         bool wifi_connected = false;
 372         u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 373         u8 tmp;
 374
 375         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 376                            &wifi_connected);
 377         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 378         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 379         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
 380                            &under_4way);
 381
 382         if (wifi_connected) {
 383                 if (wifi_busy != pre_wifi_busy) {
 384                         pre_wifi_busy = wifi_busy;
 385                         return true;
 386                 }
 387
 388                 if (under_4way != pre_under_4way) {
 389                         pre_under_4way = under_4way;
 390                         return true;
 391                 }
 392
 393                 if (bt_hs_on != pre_bt_hs_on) {
 394                         pre_bt_hs_on = bt_hs_on;
 395                         return true;
 396                 }
 397
 398                 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
 399                                  coex_dm->switch_thres_offset;
 400                 wifi_rssi_state =
 401                      btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, tmp, 0);
 402
 403                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
 404                     (wifi_rssi_state == BTC_RSSI_STATE_LOW))
 405                         return true;
 406         }
 407
 408         return false;
 409 }
 410
 411 static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist)
 412 {
 413         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 414         bool bt_hs_on = false;
 415
 416         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 417
 418         bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
 419         bt_link_info->sco_exist = coex_sta->sco_exist;
 420         bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
 421         bt_link_info->pan_exist = coex_sta->pan_exist;
 422         bt_link_info->hid_exist = coex_sta->hid_exist;
 423
 424         /* work around for HS mode. */
 425         if (bt_hs_on) {
 426                 bt_link_info->pan_exist = true;
 427                 bt_link_info->bt_link_exist = true;
 428         }
 429
 430         /* check if Sco only */
 431         if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 432             !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 433                 bt_link_info->sco_only = true;
 434         else
 435                 bt_link_info->sco_only = false;
 436
 437         /* check if A2dp only */
 438         if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
 439             !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 440                 bt_link_info->a2dp_only = true;
 441         else
 442                 bt_link_info->a2dp_only = false;
 443
 444         /* check if Pan only */
 445         if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 446             bt_link_info->pan_exist && !bt_link_info->hid_exist)
 447                 bt_link_info->pan_only = true;
 448         else
 449                 bt_link_info->pan_only = false;
 450
 451         /* check if Hid only */
 452         if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 453             !bt_link_info->pan_exist && bt_link_info->hid_exist)
 454                 bt_link_info->hid_only = true;
 455         else
 456                 bt_link_info->hid_only = false;
 457 }
 458
 459 static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
 460 {
 461         struct rtl_priv *rtlpriv = btcoexist->adapter;
 462         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 463         bool bt_hs_on = false;
 464         u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
 465         u8 num_of_diff_profile = 0;
 466
 467         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 468
 469         if (!bt_link_info->bt_link_exist) {
 470                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 471                          "[BTCoex], No BT link exists!!!\n");
 472                 return algorithm;
 473         }
 474
 475         if (bt_link_info->sco_exist)
 476                 num_of_diff_profile++;
 477         if (bt_link_info->hid_exist)
 478                 num_of_diff_profile++;
 479         if (bt_link_info->pan_exist)
 480                 num_of_diff_profile++;
 481         if (bt_link_info->a2dp_exist)
 482                 num_of_diff_profile++;
 483
 484         if (num_of_diff_profile == 1) {
 485                 if (bt_link_info->sco_exist) {
 486                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 487                                  "[BTCoex], SCO only\n");
 488                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 489                 } else {
 490                         if (bt_link_info->hid_exist) {
 491                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 492                                          "[BTCoex], HID only\n");
 493                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 494                         } else if (bt_link_info->a2dp_exist) {
 495                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 496                                          "[BTCoex], A2DP only\n");
 497                                 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
 498                         } else if (bt_link_info->pan_exist) {
 499                                 if (bt_hs_on) {
 500                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 501                                                  DBG_LOUD,
 502                                                  "[BTCoex], PAN(HS) only\n");
 503                                         algorithm =
 504                                                 BT_8723B_2ANT_COEX_ALGO_PANHS;
 505                                 } else {
 506                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 507                                                  DBG_LOUD,
 508                                                  "[BTCoex], PAN(EDR) only\n");
 509                                         algorithm =
 510                                                 BT_8723B_2ANT_COEX_ALGO_PANEDR;
 511                                 }
 512                         }
 513                 }
 514         } else if (num_of_diff_profile == 2) {
 515                 if (bt_link_info->sco_exist) {
 516                         if (bt_link_info->hid_exist) {
 517                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 518                                          "[BTCoex], SCO + HID\n");
 519                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 520                         } else if (bt_link_info->a2dp_exist) {
 521                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 522                                          "[BTCoex], SCO + A2DP ==> SCO\n");
 523                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 524                         } else if (bt_link_info->pan_exist) {
 525                                 if (bt_hs_on) {
 526                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 527                                                  DBG_LOUD,
 528                                                  "[BTCoex], SCO + PAN(HS)\n");
 529                                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 530                                 } else {
 531                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 532                                                  DBG_LOUD,
 533                                                  "[BTCoex], SCO + PAN(EDR)\n");
 534                                         algorithm =
 535                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 536                                 }
 537                         }
 538                 } else {
 539                         if (bt_link_info->hid_exist &&
 540                             bt_link_info->a2dp_exist) {
 541                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 542                                          "[BTCoex], HID + A2DP\n");
 543                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 544                         } else if (bt_link_info->hid_exist &&
 545                                    bt_link_info->pan_exist) {
 546                                 if (bt_hs_on) {
 547                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 548                                                  DBG_LOUD,
 549                                                  "[BTCoex], HID + PAN(HS)\n");
 550                                         algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 551                                 } else {
 552                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 553                                                  DBG_LOUD,
 554                                                  "[BTCoex], HID + PAN(EDR)\n");
 555                                         algorithm =
 556                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 557                                 }
 558                         } else if (bt_link_info->pan_exist &&
 559                                    bt_link_info->a2dp_exist) {
 560                                 if (bt_hs_on) {
 561                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 562                                                  DBG_LOUD,
 563                                                  "[BTCoex], A2DP + PAN(HS)\n");
 564                                         algorithm =
 565                                             BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
 566                                 } else {
 567                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 568                                                  DBG_LOUD,
 569                                                  "[BTCoex],A2DP + PAN(EDR)\n");
 570                                         algorithm =
 571                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
 572                                 }
 573                         }
 574                 }
 575         } else if (num_of_diff_profile == 3) {
 576                 if (bt_link_info->sco_exist) {
 577                         if (bt_link_info->hid_exist &&
 578                             bt_link_info->a2dp_exist) {
 579                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 580                                          "[BTCoex], SCO + HID + A2DP ==> HID\n");
 581                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 582                         } else if (bt_link_info->hid_exist &&
 583                                    bt_link_info->pan_exist) {
 584                                 if (bt_hs_on) {
 585                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 586                                                  DBG_LOUD,
 587                                                  "[BTCoex], SCO + HID + PAN(HS)\n");
 588                                         algorithm =
 589                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 590                                 } else {
 591                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 592                                                  DBG_LOUD,
 593                                                  "[BTCoex], SCO + HID + PAN(EDR)\n");
 594                                         algorithm =
 595                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 596                                 }
 597                         } else if (bt_link_info->pan_exist &&
 598                                    bt_link_info->a2dp_exist) {
 599                                 if (bt_hs_on) {
 600                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 601                                                  DBG_LOUD,
 602                                                  "[BTCoex], SCO + A2DP + PAN(HS)\n");
 603                                         algorithm =
 604                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 605                                 } else {
 606                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 607                                                  DBG_LOUD,
 608                                                  "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
 609                                         algorithm =
 610                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 611                                 }
 612                         }
 613                 } else {
 614                         if (bt_link_info->hid_exist &&
 615                             bt_link_info->pan_exist &&
 616                             bt_link_info->a2dp_exist) {
 617                                 if (bt_hs_on) {
 618                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 619                                                  DBG_LOUD,
 620                                                  "[BTCoex], HID + A2DP + PAN(HS)\n");
 621                                         algorithm =
 622                                             BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 623                                 } else {
 624                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 625                                                  DBG_LOUD,
 626                                                  "[BTCoex], HID + A2DP + PAN(EDR)\n");
 627                                         algorithm =
 628                                         BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
 629                                 }
 630                         }
 631                 }
 632         } else if (num_of_diff_profile >= 3) {
 633                 if (bt_link_info->sco_exist) {
 634                         if (bt_link_info->hid_exist &&
 635                             bt_link_info->pan_exist &&
 636                             bt_link_info->a2dp_exist) {
 637                                 if (bt_hs_on) {
 638                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 639                                                  DBG_LOUD,
 640                                                  "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
 641                                 } else {
 642                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 643                                                  DBG_LOUD,
 644                                                  "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
 645                                         algorithm =
 646                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 647                                 }
 648                         }
 649                 }
 650         }
 651         return algorithm;
 652 }
 653
 654 static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
 655                                                 u8 dac_swing_lvl)
 656 {
 657         struct rtl_priv *rtlpriv = btcoexist->adapter;
 658         u8 h2c_parameter[1] = {0};
 659
 660         /* There are several type of dacswing
 661          * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
 662          */
 663         h2c_parameter[0] = dac_swing_lvl;
 664
 665         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 666                  "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
 667         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 668                  "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
 669
 670         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 671 }
 672
 673 static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
 674                                            u8 dec_bt_pwr_lvl)
 675 {
 676         struct rtl_priv *rtlpriv = btcoexist->adapter;
 677         u8 h2c_parameter[1] = {0};
 678
 679         h2c_parameter[0] = dec_bt_pwr_lvl;
 680
 681         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 682                  "[BTCoex], decrease Bt Power Level : %u\n", dec_bt_pwr_lvl);
 683
 684         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 685 }
 686
 687 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
 688                                     bool force_exec, u8 dec_bt_pwr_lvl)
 689 {
 690         struct rtl_priv *rtlpriv = btcoexist->adapter;
 691
 692         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 693                  "[BTCoex], Dec BT power level = %u\n", dec_bt_pwr_lvl);
 694         coex_dm->cur_dec_bt_pwr_lvl = dec_bt_pwr_lvl;
 695
 696         if (!force_exec) {
 697                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 698                          "[BTCoex], PreDecBtPwrLvl=%d, CurDecBtPwrLvl=%d\n",
 699                             coex_dm->pre_dec_bt_pwr_lvl,
 700                             coex_dm->cur_dec_bt_pwr_lvl);
 701
 702                 if (coex_dm->pre_dec_bt_pwr_lvl == coex_dm->cur_dec_bt_pwr_lvl)
 703                         return;
 704         }
 705         btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr_lvl);
 706
 707         coex_dm->pre_dec_bt_pwr_lvl = coex_dm->cur_dec_bt_pwr_lvl;
 708 }
 709
 710 static
 711 void halbtc8723b2ant_set_bt_auto_report(struct btc_coexist *btcoexist,
 712                                         bool enable_auto_report)
 713 {
 714         u8 h2c_parameter[1] = {0};
 715
 716         h2c_parameter[0] = 0;
 717
 718         if (enable_auto_report)
 719                 h2c_parameter[0] |= BIT(0);
 720
 721         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 722 }
 723
 724 static
 725 void btc8723b2ant_bt_auto_report(struct btc_coexist *btcoexist,
 726                                  bool force_exec, bool enable_auto_report)
 727 {
 728         coex_dm->cur_bt_auto_report = enable_auto_report;
 729
 730         if (!force_exec) {
 731                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
 732                         return;
 733         }
 734         halbtc8723b2ant_set_bt_auto_report(btcoexist,
 735                                            coex_dm->cur_bt_auto_report);
 736
 737         coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
 738 }
 739
 740 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
 741                                           bool force_exec, u8 fw_dac_swing_lvl)
 742 {
 743         struct rtl_priv *rtlpriv = btcoexist->adapter;
 744
 745         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 746                  "[BTCoex], %s set FW Dac Swing level = %d\n",
 747                     (force_exec ? "force to" : ""), fw_dac_swing_lvl);
 748         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 749
 750         if (!force_exec) {
 751                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 752                          "[BTCoex], preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
 753                             coex_dm->pre_fw_dac_swing_lvl,
 754                             coex_dm->cur_fw_dac_swing_lvl);
 755
 756                 if (coex_dm->pre_fw_dac_swing_lvl ==
 757                    coex_dm->cur_fw_dac_swing_lvl)
 758                         return;
 759         }
 760
 761         btc8723b2ant_set_fw_dac_swing_level(btcoexist,
 762                                             coex_dm->cur_fw_dac_swing_lvl);
 763         coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
 764 }
 765
 766 static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
 767                                         bool low_penalty_ra)
 768 {
 769         struct rtl_priv *rtlpriv = btcoexist->adapter;
 770         u8 h2c_parameter[6] = {0};
 771
 772         h2c_parameter[0] = 0x6; /* op_code, 0x6 = Retry_Penalty */
 773
 774         if (low_penalty_ra) {
 775                 h2c_parameter[1] |= BIT0;
 776                 /* normal rate except MCS7/6/5, OFDM54/48/36 */
 777                 h2c_parameter[2] = 0x00;
 778                 h2c_parameter[3] = 0xf4; /* MCS7 or OFDM54 */
 779                 h2c_parameter[4] = 0xf5; /* MCS6 or OFDM48 */
 780                 h2c_parameter[5] = 0xf6; /* MCS5 or OFDM36 */
 781         }
 782
 783         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 784                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
 785                  (low_penalty_ra ? "ON!!" : "OFF!!"));
 786
 787         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 788 }
 789
 790 static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
 791                                         bool force_exec, bool low_penalty_ra)
 792 {
 793         struct rtl_priv *rtlpriv = btcoexist->adapter;
 794
 795         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 796                  "[BTCoex], %s turn LowPenaltyRA = %s\n",
 797                  (force_exec ? "force to" : ""), (low_penalty_ra ?
 798                                                   "ON" : "OFF"));
 799         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 800
 801         if (!force_exec) {
 802                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 803                          "[BTCoex], bPreLowPenaltyRa=%d, bCurLowPenaltyRa=%d\n",
 804                          coex_dm->pre_low_penalty_ra,
 805                          coex_dm->cur_low_penalty_ra);
 806
 807                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 808                         return;
 809         }
 810         btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra);
 811
 812         coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 813 }
 814
 815 static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
 816                                            u32 level)
 817 {
 818         struct rtl_priv *rtlpriv = btcoexist->adapter;
 819         u8 val = (u8) level;
 820
 821         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 822                  "[BTCoex], Write SwDacSwing = 0x%x\n", level);
 823         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
 824 }
 825
 826 static void btc8723b2ant_set_sw_fulltime_dac_swing(struct btc_coexist *btcoex,
 827                                                    bool sw_dac_swing_on,
 828                                                    u32 sw_dac_swing_lvl)
 829 {
 830         if (sw_dac_swing_on)
 831                 btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl);
 832         else
 833                 btc8723b2ant_set_dac_swing_reg(btcoex, 0x18);
 834 }
 835
 836 void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
 837                             bool force_exec, bool dac_swing_on,
 838                             u32 dac_swing_lvl)
 839 {
 840         struct rtl_priv *rtlpriv = btcoexist->adapter;
 841
 842         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 843                  "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
 844                  (force_exec ? "force to" : ""),
 845                  (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
 846         coex_dm->cur_dac_swing_on = dac_swing_on;
 847         coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
 848
 849         if (!force_exec) {
 850                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 851                          "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x, bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
 852                          coex_dm->pre_dac_swing_on,
 853                          coex_dm->pre_dac_swing_lvl,
 854                          coex_dm->cur_dac_swing_on,
 855                          coex_dm->cur_dac_swing_lvl);
 856
 857                 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
 858                     (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
 859                         return;
 860         }
 861         mdelay(30);
 862         btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on,
 863                                                dac_swing_lvl);
 864
 865         coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
 866         coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
 867 }
 868
 869 static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
 870                                         u32 val0x6c0, u32 val0x6c4,
 871                                         u32 val0x6c8, u8 val0x6cc)
 872 {
 873         struct rtl_priv *rtlpriv = btcoexist->adapter;
 874
 875         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 876                  "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
 877         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 878
 879         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 880                  "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
 881         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 882
 883         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 884                  "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
 885         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 886
 887         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 888                  "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
 889         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 890 }
 891
 892 static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
 893                                     bool force_exec, u32 val0x6c0,
 894                                     u32 val0x6c4, u32 val0x6c8,
 895                                     u8 val0x6cc)
 896 {
 897         struct rtl_priv *rtlpriv = btcoexist->adapter;
 898
 899         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 900                  "[BTCoex], %s write Coex Table 0x6c0=0x%x, 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
 901                  force_exec ? "force to" : "",
 902                  val0x6c0, val0x6c4, val0x6c8, val0x6cc);
 903         coex_dm->cur_val0x6c0 = val0x6c0;
 904         coex_dm->cur_val0x6c4 = val0x6c4;
 905         coex_dm->cur_val0x6c8 = val0x6c8;
 906         coex_dm->cur_val0x6cc = val0x6cc;
 907
 908         if (!force_exec) {
 909                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 910                          "[BTCoex], preVal0x6c0=0x%x, preVal0x6c4=0x%x, preVal0x6c8=0x%x, preVal0x6cc=0x%x !!\n",
 911                          coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
 912                          coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
 913                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 914                          "[BTCoex], curVal0x6c0=0x%x, curVal0x6c4=0x%x, curVal0x6c8=0x%x, curVal0x6cc=0x%x !!\n",
 915                          coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
 916                          coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
 917
 918                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
 919                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
 920                     (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
 921                     (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
 922                         return;
 923         }
 924         btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
 925                                     val0x6c8, val0x6cc);
 926
 927         coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
 928         coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
 929         coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
 930         coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
 931 }
 932
 933 static void btc8723b2ant_coex_table_with_type(struct btc_coexist *btcoexist,
 934                                               bool force_exec, u8 type)
 935 {
 936         switch (type) {
 937         case 0:
 938                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
 939                                         0x55555555, 0xffffff, 0x3);
 940                 break;
 941         case 1:
 942                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
 943                                         0x5afa5afa, 0xffffff, 0x3);
 944                 break;
 945         case 2:
 946                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5ada5ada,
 947                                         0x5ada5ada, 0xffffff, 0x3);
 948                 break;
 949         case 3:
 950                 btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
 951                                         0xaaaaaaaa, 0xffffff, 0x3);
 952                 break;
 953         case 4:
 954                 btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff,
 955                                         0xffffffff, 0xffffff, 0x3);
 956                 break;
 957         case 5:
 958                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
 959                                         0x5fff5fff, 0xffffff, 0x3);
 960                 break;
 961         case 6:
 962                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
 963                                         0x5a5a5a5a, 0xffffff, 0x3);
 964                 break;
 965         case 7:
 966                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 967                                         0x5ada5ada, 0xffffff, 0x3);
 968                 break;
 969         case 8:
 970                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 971                                         0x5ada5ada, 0xffffff, 0x3);
 972                 break;
 973         case 9:
 974                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 975                                         0x5ada5ada, 0xffffff, 0x3);
 976                 break;
 977         case 10:
 978                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 979                                         0x5ada5ada, 0xffffff, 0x3);
 980                 break;
 981         case 11:
 982                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 983                                         0x5ada5ada, 0xffffff, 0x3);
 984                 break;
 985         case 12:
 986                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 987                                         0x5ada5ada, 0xffffff, 0x3);
 988                 break;
 989         case 13:
 990                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
 991                                         0xaaaaaaaa, 0xffffff, 0x3);
 992                 break;
 993         case 14:
 994                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
 995                                         0x5ada5ada, 0xffffff, 0x3);
 996                 break;
 997         case 15:
 998                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 999                                         0xaaaaaaaa, 0xffffff, 0x3);
1000                 break;
1001         default:
1002                 break;
1003         }
1004 }
1005
1006 static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
1007                                                 bool enable)
1008 {
1009         struct rtl_priv *rtlpriv = btcoexist->adapter;
1010         u8 h2c_parameter[1] = {0};
1011
1012         if (enable)
1013                 h2c_parameter[0] |= BIT0; /* function enable */
1014
1015         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1016                  "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63=0x%x\n",
1017                  h2c_parameter[0]);
1018
1019         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1020 }
1021
1022 static void btc8723b2ant_set_lps_rpwm(struct btc_coexist *btcoexist,
1023                                       u8 lps_val, u8 rpwm_val)
1024 {
1025         u8 lps = lps_val;
1026         u8 rpwm = rpwm_val;
1027
1028         btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1029         btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1030 }
1031
1032 static void btc8723b2ant_lps_rpwm(struct btc_coexist *btcoexist,
1033                                   bool force_exec, u8 lps_val, u8 rpwm_val)
1034 {
1035         coex_dm->cur_lps = lps_val;
1036         coex_dm->cur_rpwm = rpwm_val;
1037
1038         if (!force_exec) {
1039                 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1040                     (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1041                         return;
1042         }
1043         btc8723b2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1044
1045         coex_dm->pre_lps = coex_dm->cur_lps;
1046         coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1047 }
1048
1049 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1050                                          bool force_exec, bool enable)
1051 {
1052         struct rtl_priv *rtlpriv = btcoexist->adapter;
1053
1054         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1055                  "[BTCoex], %s turn Ignore WlanAct %s\n",
1056                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1057         coex_dm->cur_ignore_wlan_act = enable;
1058
1059         if (!force_exec) {
1060                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1061                          "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
1062                          coex_dm->pre_ignore_wlan_act,
1063                          coex_dm->cur_ignore_wlan_act);
1064
1065                 if (coex_dm->pre_ignore_wlan_act ==
1066                     coex_dm->cur_ignore_wlan_act)
1067                         return;
1068         }
1069         btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1070
1071         coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1072 }
1073
1074 static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
1075                                         u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1076 {
1077         struct rtl_priv *rtlpriv = btcoexist->adapter;
1078         u8 h2c_parameter[5];
1079         if ((coex_sta->a2dp_exist) && (coex_sta->hid_exist))
1080                 byte5 = byte5 | 0x1;
1081
1082         h2c_parameter[0] = byte1;
1083         h2c_parameter[1] = byte2;
1084         h2c_parameter[2] = byte3;
1085         h2c_parameter[3] = byte4;
1086         h2c_parameter[4] = byte5;
1087
1088         coex_dm->ps_tdma_para[0] = byte1;
1089         coex_dm->ps_tdma_para[1] = byte2;
1090         coex_dm->ps_tdma_para[2] = byte3;
1091         coex_dm->ps_tdma_para[3] = byte4;
1092         coex_dm->ps_tdma_para[4] = byte5;
1093
1094         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1095                  "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
1096                  h2c_parameter[0],
1097                  h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1098                  h2c_parameter[3] << 8 | h2c_parameter[4]);
1099
1100         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1101 }
1102
1103 static void btc8723b2ant_sw_mechanism(struct btc_coexist *btcoexist,
1104                                       bool shrink_rx_lpf, bool low_penalty_ra,
1105                                       bool limited_dig, bool bt_lna_constrain)
1106 {
1107         btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1108 }
1109
1110 static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
1111                                       u8 antpos_type, bool init_hwcfg,
1112                                       bool wifi_off)
1113 {
1114         struct btc_board_info *board_info = &btcoexist->board_info;
1115         u32 fw_ver = 0, u32tmp = 0;
1116         bool pg_ext_switch = false;
1117         bool use_ext_switch = false;
1118         u8 h2c_parameter[2] = {0};
1119
1120         btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
1121         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
1122
1123         if ((fw_ver < 0xc0000) || pg_ext_switch)
1124                 use_ext_switch = true;
1125
1126         if (init_hwcfg) {
1127                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
1128                 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
1129                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
1130                 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
1131                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
1132
1133                 if (fw_ver >= 0x180000) {
1134                         /* Use H2C to set GNT_BT to High to avoid A2DP click */
1135                         h2c_parameter[0] = 1;
1136                         btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1137                                                 h2c_parameter);
1138                 } else {
1139                         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
1140                 }
1141
1142                 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
1143
1144                 /* WiFi TRx Mask off */
1145                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1146                                           0x1, 0xfffff, 0x0);
1147
1148                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1149                         /* tell firmware "no antenna inverse" */
1150                         h2c_parameter[0] = 0;
1151                 } else {
1152                         /* tell firmware "antenna inverse" */
1153                         h2c_parameter[0] = 1;
1154                 }
1155
1156                 if (use_ext_switch) {
1157                         /* ext switch type */
1158                         h2c_parameter[1] = 1;
1159                 } else {
1160                         /* int switch type */
1161                         h2c_parameter[1] = 0;
1162                 }
1163                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, h2c_parameter);
1164         } else {
1165                 if (fw_ver >= 0x180000) {
1166                         /* Use H2C to set GNT_BT to "Control by PTA"*/
1167                         h2c_parameter[0] = 0;
1168                         btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1169                                                 h2c_parameter);
1170                 } else {
1171                         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
1172                 }
1173         }
1174
1175         /* ext switch setting */
1176         if (use_ext_switch) {
1177                 if (init_hwcfg) {
1178                         /* 0x4c[23] = 0, 0x4c[24] = 1 Ant controlled by WL/BT */
1179                         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1180                         u32tmp &= ~BIT23;
1181                         u32tmp |= BIT24;
1182                         btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1183                 }
1184
1185                 /* fixed internal switch S1->WiFi, S0->BT */
1186                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1187                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1188                 else
1189                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1190
1191                 switch (antpos_type) {
1192                 case BTC_ANT_WIFI_AT_MAIN:
1193                         /* ext switch main at wifi */
1194                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
1195                                                            0x3, 0x1);
1196                         break;
1197                 case BTC_ANT_WIFI_AT_AUX:
1198                         /* ext switch aux at wifi */
1199                         btcoexist->btc_write_1byte_bitmask(btcoexist,
1200                                                            0x92c, 0x3, 0x2);
1201                         break;
1202                 }
1203         } else {
1204                 /* internal switch */
1205                 if (init_hwcfg) {
1206                         /* 0x4c[23] = 0, 0x4c[24] = 1 Ant controlled by WL/BT */
1207                         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1208                         u32tmp |= BIT23;
1209                         u32tmp &= ~BIT24;
1210                         btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1211                 }
1212
1213                 /* fixed ext switch, S1->Main, S0->Aux */
1214                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 0x0);
1215                 switch (antpos_type) {
1216                 case BTC_ANT_WIFI_AT_MAIN:
1217                         /* fixed internal switch S1->WiFi, S0->BT */
1218                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1219                         break;
1220                 case BTC_ANT_WIFI_AT_AUX:
1221                         /* fixed internal switch S0->WiFi, S1->BT */
1222                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1223                         break;
1224                 }
1225         }
1226 }
1227
1228 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
1229                                  bool turn_on, u8 type)
1230 {
1231         struct rtl_priv *rtlpriv = btcoexist->adapter;
1232         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1233         u8 wifi_rssi_state, bt_rssi_state;
1234         s8 wifi_duration_adjust = 0x0;
1235         u8 tdma_byte4_modify = 0x0;
1236         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1237                         coex_dm->switch_thres_offset;
1238
1239         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, tmp, 0);
1240         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1241                         coex_dm->switch_thres_offset;
1242         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
1243
1244         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1245                  "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1246                  (force_exec ? "force to" : ""),
1247                  (turn_on ? "ON" : "OFF"), type);
1248         coex_dm->cur_ps_tdma_on = turn_on;
1249         coex_dm->cur_ps_tdma = type;
1250
1251         if (!(BTC_RSSI_HIGH(wifi_rssi_state) &&
1252               BTC_RSSI_HIGH(bt_rssi_state)) && turn_on) {
1253                  /* for WiFi RSSI low or BT RSSI low */
1254                 type = type + 100;
1255                 coex_dm->is_switch_to_1dot5_ant = true;
1256         } else {
1257                 coex_dm->is_switch_to_1dot5_ant = false;
1258         }
1259
1260         if (!force_exec) {
1261                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1262                          "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1263                          coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1264                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1265                          "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1266                          coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1267
1268                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1269                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1270                         return;
1271         }
1272
1273         if (coex_sta->scan_ap_num <= 5) {
1274                 if (coex_sta->a2dp_bit_pool >= 45)
1275                         wifi_duration_adjust = -15;
1276                 else if (coex_sta->a2dp_bit_pool >= 35)
1277                         wifi_duration_adjust = -10;
1278                 else
1279                         wifi_duration_adjust = 5;
1280         } else if (coex_sta->scan_ap_num <= 20) {
1281                 if (coex_sta->a2dp_bit_pool >= 45)
1282                         wifi_duration_adjust = -15;
1283                 else if (coex_sta->a2dp_bit_pool >= 35)
1284                         wifi_duration_adjust = -10;
1285                 else
1286                         wifi_duration_adjust = 0;
1287         } else if (coex_sta->scan_ap_num <= 40) {
1288                 if (coex_sta->a2dp_bit_pool >= 45)
1289                         wifi_duration_adjust = -15;
1290                 else if (coex_sta->a2dp_bit_pool >= 35)
1291                         wifi_duration_adjust = -10;
1292                 else
1293                         wifi_duration_adjust = -5;
1294         } else {
1295                 if (coex_sta->a2dp_bit_pool >= 45)
1296                         wifi_duration_adjust = -15;
1297                 else if (coex_sta->a2dp_bit_pool >= 35)
1298                         wifi_duration_adjust = -10;
1299                 else
1300                         wifi_duration_adjust = -10;
1301         }
1302
1303         if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1304                 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1305                 tdma_byte4_modify = 0x1;
1306
1307         if (turn_on) {
1308                 switch (type) {
1309                 case 1:
1310                 default:
1311                         btc8723b2ant_set_fw_ps_tdma(
1312                                 btcoexist, 0xe3, 0x3c,
1313                                 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1314                         break;
1315                 case 2:
1316                         btc8723b2ant_set_fw_ps_tdma(
1317                                 btcoexist, 0xe3, 0x2d,
1318                                 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1319                         break;
1320                 case 3:
1321                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1322                                                     0x3, 0xf1,
1323                                                     0x90 | tdma_byte4_modify);
1324                         break;
1325                 case 4:
1326                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1327                                                     0x03, 0xf1,
1328                                                     0x90 | tdma_byte4_modify);
1329                         break;
1330                 case 5:
1331                         btc8723b2ant_set_fw_ps_tdma(
1332                                 btcoexist, 0xe3, 0x3c,
1333                                 0x3, 0x70, 0x90 | tdma_byte4_modify);
1334                         break;
1335                 case 6:
1336                         btc8723b2ant_set_fw_ps_tdma(
1337                                 btcoexist, 0xe3, 0x2d,
1338                                 0x3, 0x70, 0x90 | tdma_byte4_modify);
1339                         break;
1340                 case 7:
1341                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1342                                                     0x3, 0x70,
1343                                                     0x90 | tdma_byte4_modify);
1344                         break;
1345                 case 8:
1346                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1347                                                     0x3, 0x70,
1348                                                     0x90 | tdma_byte4_modify);
1349                         break;
1350                 case 9:
1351                         btc8723b2ant_set_fw_ps_tdma(
1352                                 btcoexist, 0xe3, 0x3c + wifi_duration_adjust,
1353                                 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1354                         break;
1355                 case 10:
1356                         btc8723b2ant_set_fw_ps_tdma(
1357                                 btcoexist, 0xe3, 0x2d,
1358                                 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1359                         break;
1360                 case 11:
1361                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1362                                                     0x3, 0xf1,
1363                                                     0x90 | tdma_byte4_modify);
1364                         break;
1365                 case 12:
1366                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1367                                                     0x3, 0xf1,
1368                                                     0x90 | tdma_byte4_modify);
1369                         break;
1370                 case 13:
1371                         btc8723b2ant_set_fw_ps_tdma(
1372                                 btcoexist, 0xe3, 0x3c,
1373                                 0x3, 0x70, 0x90 | tdma_byte4_modify);
1374                         break;
1375                 case 14:
1376                         btc8723b2ant_set_fw_ps_tdma(
1377                                 btcoexist, 0xe3, 0x2d,
1378                                 0x3, 0x70, 0x90 | tdma_byte4_modify);
1379                         break;
1380                 case 15:
1381                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1382                                                     0x3, 0x70,
1383                                                     0x90 | tdma_byte4_modify);
1384                         break;
1385                 case 16:
1386                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1387                                                     0x3, 0x70,
1388                                                     0x90 | tdma_byte4_modify);
1389                         break;
1390                 case 17:
1391                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1392                                                     0x2f, 0x60, 0x90);
1393                         break;
1394                 case 18:
1395                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 0x5,
1396                                                     0xe1, 0x90);
1397                         break;
1398                 case 19:
1399                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1400                                                     0x25, 0xe1, 0x90);
1401                         break;
1402                 case 20:
1403                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1404                                                     0x25, 0x60, 0x90);
1405                         break;
1406                 case 21:
1407                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1408                                                     0x03, 0x70, 0x90);
1409                         break;
1410
1411                 case 23:
1412                 case 123:
1413                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1414                                                     0x03, 0x71, 0x10);
1415                         break;
1416                 case 71:
1417                         btc8723b2ant_set_fw_ps_tdma(
1418                                 btcoexist, 0xe3, 0x3c + wifi_duration_adjust,
1419                                 0x03, 0xf1, 0x90);
1420                         break;
1421                 case 101:
1422                 case 105:
1423                 case 113:
1424                 case 171:
1425                         btc8723b2ant_set_fw_ps_tdma(
1426                                 btcoexist, 0xd3, 0x3a + wifi_duration_adjust,
1427                                 0x03, 0x70, 0x50 | tdma_byte4_modify);
1428                         break;
1429                 case 102:
1430                 case 106:
1431                 case 110:
1432                 case 114:
1433                         btc8723b2ant_set_fw_ps_tdma(
1434                                 btcoexist, 0xd3, 0x2d + wifi_duration_adjust,
1435                                 0x03, 0x70, 0x50 | tdma_byte4_modify);
1436                         break;
1437                 case 103:
1438                 case 107:
1439                 case 111:
1440                 case 115:
1441                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1442                                                     0x03, 0x70,
1443                                                     0x50 | tdma_byte4_modify);
1444                         break;
1445                 case 104:
1446                 case 108:
1447                 case 112:
1448                 case 116:
1449                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x10,
1450                                                     0x03, 0x70,
1451                                                     0x50 | tdma_byte4_modify);
1452                         break;
1453                 case 109:
1454                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1455                                                     0x03, 0xf1,
1456                                                     0x90 | tdma_byte4_modify);
1457                         break;
1458                 case 121:
1459                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1460                                                     0x03, 0x70,
1461                                                     0x90 | tdma_byte4_modify);
1462                         break;
1463                 case 22:
1464                 case 122:
1465                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1466                                                     0x03, 0x71, 0x11);
1467                         break;
1468                 }
1469         } else {
1470                 /* disable PS tdma */
1471                 switch (type) {
1472                 case 0:
1473                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1474                                                     0x40, 0x0);
1475                         break;
1476                 case 1:
1477                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1478                                                     0x48, 0x0);
1479                         break;
1480                 default:
1481                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1482                                                     0x40, 0x0);
1483                         break;
1484                 }
1485         }
1486
1487         /* update pre state */
1488         coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1489         coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1490 }
1491
1492 static void btc8723b2ant_ps_tdma_check_for_power_save_state(
1493                 struct btc_coexist *btcoexist, bool new_ps_state)
1494 {
1495         u8 lps_mode = 0x0;
1496
1497         btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1498
1499         if (lps_mode) {
1500                 /* already under LPS state */
1501                 if (new_ps_state) {
1502                         /* keep state under LPS, do nothing. */
1503                 } else {
1504                         /* will leave LPS state, turn off psTdma first */
1505                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1506                 }
1507         } else {
1508                 /* NO PS state */
1509                 if (new_ps_state) {
1510                         /* will enter LPS state, turn off psTdma first */
1511                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1512                 } else {
1513                         /* keep state under NO PS state, do nothing. */
1514                 }
1515         }
1516 }
1517
1518 static void btc8723b2ant_power_save_state(struct btc_coexist *btcoexist,
1519                                           u8 ps_type, u8 lps_val, u8 rpwm_val)
1520 {
1521         bool low_pwr_disable = false;
1522
1523         switch (ps_type) {
1524         case BTC_PS_WIFI_NATIVE:
1525                 /* recover to original 32k low power setting */
1526                 low_pwr_disable = false;
1527                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1528                                    &low_pwr_disable);
1529                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1530                 coex_sta->force_lps_on = false;
1531                 break;
1532         case BTC_PS_LPS_ON:
1533                 btc8723b2ant_ps_tdma_check_for_power_save_state(btcoexist,
1534                                                                 true);
1535                 btc8723b2ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1536                                       rpwm_val);
1537                 /* when coex force to enter LPS, do not enter 32k low power */
1538                 low_pwr_disable = true;
1539                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1540                                    &low_pwr_disable);
1541                 /* power save must executed before psTdma */
1542                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1543                 coex_sta->force_lps_on = true;
1544                 break;
1545         case BTC_PS_LPS_OFF:
1546                 btc8723b2ant_ps_tdma_check_for_power_save_state(btcoexist,
1547                                                                 false);
1548                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1549                 coex_sta->force_lps_on = false;
1550                 break;
1551         default:
1552                 break;
1553         }
1554 }
1555
1556 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1557 {
1558         /* fw all off */
1559         btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1560         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1561         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1562         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1563
1564         /* sw all off */
1565         btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1566
1567         /* hw all off */
1568         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1569         btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1570 }
1571
1572 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1573 {
1574         /* force to reset coex mechanism*/
1575         btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1576         btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1577
1578         btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1579         btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1580         btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 0);
1581
1582         btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1583
1584         coex_sta->pop_event_cnt = 0;
1585 }
1586
1587 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1588 {
1589         struct rtl_priv *rtlpriv = btcoexist->adapter;
1590         bool wifi_connected = false;
1591         bool low_pwr_disable = true;
1592         bool scan = false, link = false, roam = false;
1593
1594         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1595                            &low_pwr_disable);
1596         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1597                            &wifi_connected);
1598
1599         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1600         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1601         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1602
1603         btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1604
1605         if (coex_sta->bt_abnormal_scan) {
1606                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
1607                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
1608         } else if (scan || link || roam) {
1609                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1610                          "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1611                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1612                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1613         } else if (wifi_connected) {
1614                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1615                          "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1616                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1617                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1618         } else {
1619                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1620                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1621         }
1622         btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1623         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1624
1625         btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1626 }
1627
1628 static void btc8723b2ant_action_wifi_link_process(struct btc_coexist
1629                                                      *btcoexist)
1630 {
1631         struct rtl_priv *rtlpriv = btcoexist->adapter;
1632         u32 u32tmp;
1633         u8 u8tmpa, u8tmpb;
1634
1635         btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1636         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1637
1638         btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1639
1640         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
1641         u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1642         u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1643
1644         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1645                  "[BTCoex], 0x948 = 0x%x, 0x765 = 0x%x, 0x76e = 0x%x\n",
1646                  u32tmp, u8tmpa, u8tmpb);
1647 }
1648
1649 static bool btc8723b2ant_action_wifi_idle_process(struct btc_coexist *btcoexist)
1650 {
1651         struct rtl_priv *rtlpriv = btcoexist->adapter;
1652         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1653         u8 ap_num = 0;
1654         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1655                  coex_dm->switch_thres_offset - coex_dm->switch_thres_offset;
1656
1657         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1658         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
1659                                                         tmp, 0);
1660         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1661               coex_dm->switch_thres_offset - coex_dm->switch_thres_offset;
1662         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
1663
1664         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1665
1666         /* office environment */
1667         if (BTC_RSSI_HIGH(wifi_rssi_state1) && (coex_sta->hid_exist) &&
1668             (coex_sta->a2dp_exist)) {
1669                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1670                          "[BTCoex], Wifi  idle process for BT HID+A2DP exist!!\n");
1671
1672                 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1673                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1674
1675                 /* sw all off */
1676                 btc8723b2ant_sw_mechanism(btcoexist, false, false, false,
1677                                           false);
1678                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1679                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1680                                               0x0, 0x0);
1681                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1682
1683                 return true;
1684         }
1685
1686         btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1687         return false;
1688 }
1689
1690 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1691 {
1692         struct rtl_priv *rtlpriv = btcoexist->adapter;
1693         bool common = false, wifi_connected = false;
1694         bool wifi_busy = false;
1695         bool bt_hs_on = false, low_pwr_disable = false;
1696
1697         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1698         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1699                            &wifi_connected);
1700         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1701
1702         if (!wifi_connected) {
1703                 low_pwr_disable = false;
1704                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1705                                    &low_pwr_disable);
1706                 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1707                                         false, false, 0x8);
1708
1709                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1710                          "[BTCoex], Wifi non-connected idle!!\n");
1711
1712                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1713                                           0x0);
1714                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1715                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1716                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1717                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1718
1719                 btc8723b2ant_sw_mechanism(btcoexist, false, false, false,
1720                                           false);
1721
1722                 common = true;
1723         } else {
1724                 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1725                     coex_dm->bt_status) {
1726                         low_pwr_disable = false;
1727                         btcoexist->btc_set(btcoexist,
1728                                            BTC_SET_ACT_DISABLE_LOW_POWER,
1729                                            &low_pwr_disable);
1730                         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1731                                                 false, false, 0x8);
1732
1733                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1734                                  "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1735
1736                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1737                                                   0xfffff, 0x0);
1738                         btc8723b2ant_coex_table_with_type(btcoexist,
1739                                                           NORMAL_EXEC, 0);
1740                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1741                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1742                                                       0xb);
1743                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1744
1745                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
1746                                                   false, false);
1747
1748                         common = true;
1749                 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1750                            coex_dm->bt_status) {
1751                         low_pwr_disable = true;
1752                         btcoexist->btc_set(btcoexist,
1753                                            BTC_SET_ACT_DISABLE_LOW_POWER,
1754                                            &low_pwr_disable);
1755
1756                         if (bt_hs_on)
1757                                 return false;
1758                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1759                                  "[BTCoex], Wifi connected + BT connected-idle!!\n");
1760                         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1761                                                 false, false, 0x8);
1762
1763                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1764                                                   0xfffff, 0x0);
1765                         btc8723b2ant_coex_table_with_type(btcoexist,
1766                                                           NORMAL_EXEC, 0);
1767                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1768                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1769                                                       0xb);
1770                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1771
1772                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
1773                                                   false, false);
1774
1775                         common = true;
1776                 } else {
1777                         low_pwr_disable = true;
1778                         btcoexist->btc_set(btcoexist,
1779                                            BTC_SET_ACT_DISABLE_LOW_POWER,
1780                                            &low_pwr_disable);
1781
1782                         if (wifi_busy) {
1783                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1784                                          "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1785                                 common = false;
1786                         } else {
1787                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1788                                          "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1789
1790                                 common =
1791                                     btc8723b2ant_action_wifi_idle_process(
1792                                                 btcoexist);
1793                         }
1794                 }
1795         }
1796
1797         return common;
1798 }
1799
1800 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
1801                                           bool sco_hid, bool tx_pause,
1802                                           u8 max_interval)
1803 {
1804         struct rtl_priv *rtlpriv = btcoexist->adapter;
1805         static s32 up, dn, m, n, wait_count;
1806         /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
1807         s32 result;
1808         u8 retry_count = 0;
1809
1810         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1811                  "[BTCoex], TdmaDurationAdjust()\n");
1812
1813         if (!coex_dm->auto_tdma_adjust) {
1814                 coex_dm->auto_tdma_adjust = true;
1815                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1816                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
1817                 if (sco_hid) {
1818                         if (tx_pause) {
1819                                 if (max_interval == 1) {
1820                                         btc8723b2ant_ps_tdma(btcoexist,
1821                                                              NORMAL_EXEC,
1822                                                              true, 13);
1823                                         coex_dm->ps_tdma_du_adj_type = 13;
1824                                 } else if (max_interval == 2) {
1825                                         btc8723b2ant_ps_tdma(btcoexist,
1826                                                              NORMAL_EXEC,
1827                                                              true, 14);
1828                                         coex_dm->ps_tdma_du_adj_type = 14;
1829                                 } else if (max_interval == 3) {
1830                                         btc8723b2ant_ps_tdma(btcoexist,
1831                                                              NORMAL_EXEC,
1832                                                              true, 15);
1833                                         coex_dm->ps_tdma_du_adj_type = 15;
1834                                 } else {
1835                                         btc8723b2ant_ps_tdma(btcoexist,
1836                                                              NORMAL_EXEC,
1837                                                              true, 15);
1838                                         coex_dm->ps_tdma_du_adj_type = 15;
1839                                 }
1840                         } else {
1841                                 if (max_interval == 1) {
1842                                         btc8723b2ant_ps_tdma(btcoexist,
1843                                                              NORMAL_EXEC,
1844                                                              true, 9);
1845                                         coex_dm->ps_tdma_du_adj_type = 9;
1846                                 } else if (max_interval == 2) {
1847                                         btc8723b2ant_ps_tdma(btcoexist,
1848                                                              NORMAL_EXEC,
1849                                                              true, 10);
1850                                         coex_dm->ps_tdma_du_adj_type = 10;
1851                                 } else if (max_interval == 3) {
1852                                         btc8723b2ant_ps_tdma(btcoexist,
1853                                                              NORMAL_EXEC,
1854                                                      true, 11);
1855                                         coex_dm->ps_tdma_du_adj_type = 11;
1856                                 } else {
1857                                         btc8723b2ant_ps_tdma(btcoexist,
1858                                                              NORMAL_EXEC,
1859                                                              true, 11);
1860                                         coex_dm->ps_tdma_du_adj_type = 11;
1861                                 }
1862                         }
1863                 } else {
1864                         if (tx_pause) {
1865                                 if (max_interval == 1) {
1866                                         btc8723b2ant_ps_tdma(btcoexist,
1867                                                              NORMAL_EXEC,
1868                                                              true, 5);
1869                                         coex_dm->ps_tdma_du_adj_type = 5;
1870                                 } else if (max_interval == 2) {
1871                                         btc8723b2ant_ps_tdma(btcoexist,
1872                                                              NORMAL_EXEC,
1873                                                              true, 6);
1874                                         coex_dm->ps_tdma_du_adj_type = 6;
1875                                 } else if (max_interval == 3) {
1876                                         btc8723b2ant_ps_tdma(btcoexist,
1877                                                              NORMAL_EXEC,
1878                                                              true, 7);
1879                                         coex_dm->ps_tdma_du_adj_type = 7;
1880                                 } else {
1881                                         btc8723b2ant_ps_tdma(btcoexist,
1882                                                              NORMAL_EXEC,
1883                                                              true, 7);
1884                                         coex_dm->ps_tdma_du_adj_type = 7;
1885                                 }
1886                         } else {
1887                                 if (max_interval == 1) {
1888                                         btc8723b2ant_ps_tdma(btcoexist,
1889                                                              NORMAL_EXEC,
1890                                                              true, 1);
1891                                         coex_dm->ps_tdma_du_adj_type = 1;
1892                                 } else if (max_interval == 2) {
1893                                         btc8723b2ant_ps_tdma(btcoexist,
1894                                                              NORMAL_EXEC,
1895                                                              true, 2);
1896                                         coex_dm->ps_tdma_du_adj_type = 2;
1897                                 } else if (max_interval == 3) {
1898                                         btc8723b2ant_ps_tdma(btcoexist,
1899                                                              NORMAL_EXEC,
1900                                                              true, 3);
1901                                         coex_dm->ps_tdma_du_adj_type = 3;
1902                                 } else {
1903                                         btc8723b2ant_ps_tdma(btcoexist,
1904                                                              NORMAL_EXEC,
1905                                                              true, 3);
1906                                         coex_dm->ps_tdma_du_adj_type = 3;
1907                                 }
1908                         }
1909                 }
1910
1911                 up = 0;
1912                 dn = 0;
1913                 m = 1;
1914                 n = 3;
1915                 result = 0;
1916                 wait_count = 0;
1917         } else {
1918                 /*accquire the BT TRx retry count from BT_Info byte2*/
1919                 retry_count = coex_sta->bt_retry_cnt;
1920
1921                 if ((coex_sta->low_priority_tx) > 1050 ||
1922                     (coex_sta->low_priority_rx) > 1250)
1923                         retry_count++;
1924
1925                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1926                          "[BTCoex], retry_count = %d\n", retry_count);
1927                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1928                          "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
1929                          up, dn, m, n, wait_count);
1930                 result = 0;
1931                 wait_count++;
1932                  /* no retry in the last 2-second duration*/
1933                 if (retry_count == 0) {
1934                         up++;
1935                         dn--;
1936
1937                         if (dn <= 0)
1938                                 dn = 0;
1939
1940                         if (up >= n) {
1941                                 /* if retry count during continuous n*2
1942                                  * seconds is 0, enlarge WiFi duration
1943                                  */
1944                                 wait_count = 0;
1945                                 n = 3;
1946                                 up = 0;
1947                                 dn = 0;
1948                                 result = 1;
1949                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1950                                          "[BTCoex], Increase wifi duration!!\n");
1951                         } /* <=3 retry in the last 2-second duration*/
1952                 } else if (retry_count <= 3) {
1953                         up--;
1954                         dn++;
1955
1956                         if (up <= 0)
1957                                 up = 0;
1958
1959                         if (dn == 2) {
1960                                 /* if continuous 2 retry count(every 2
1961                                  * seconds) >0 and < 3, reduce WiFi duration
1962                                  */
1963                                 if (wait_count <= 2)
1964                                         /* avoid loop between the two levels */
1965                                         m++;
1966                                 else
1967                                         m = 1;
1968
1969                                 if (m >= 20)
1970                                         /* maximum of m = 20 ' will recheck if
1971                                          * need to adjust wifi duration in
1972                                          * maximum time interval 120 seconds
1973                                          */
1974                                         m = 20;
1975
1976                                 n = 3 * m;
1977                                 up = 0;
1978                                 dn = 0;
1979                                 wait_count = 0;
1980                                 result = -1;
1981                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1982                                          "[BTCoex], Decrease wifi duration for retry_counter<3!!\n");
1983                         }
1984                 } else {
1985                         /* retry count > 3, once retry count > 3, to reduce
1986                          *  WiFi duration
1987                          */
1988                         if (wait_count == 1)
1989                                 /* to avoid loop between the two levels */
1990                                 m++;
1991                         else
1992                                 m = 1;
1993
1994                         if (m >= 20)
1995                                 /* maximum of m = 20 ' will recheck if need to
1996                                  * adjust wifi duration in maximum time interval
1997                                  * 120 seconds
1998                                  */
1999                                 m = 20;
2000
2001                         n = 3 * m;
2002                         up = 0;
2003                         dn = 0;
2004                         wait_count = 0;
2005                         result = -1;
2006                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2007                                  "[BTCoex], Decrease wifi duration for retry_counter>3!!\n");
2008                 }
2009
2010                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2011                          "[BTCoex], max Interval = %d\n", max_interval);
2012                 if (max_interval == 1) {
2013                         if (tx_pause) {
2014                                 if (coex_dm->cur_ps_tdma == 71) {
2015                                         btc8723b2ant_ps_tdma(btcoexist,
2016                                                              NORMAL_EXEC,
2017                                                              true, 5);
2018                                         coex_dm->ps_tdma_du_adj_type = 5;
2019                                 } else if (coex_dm->cur_ps_tdma == 1) {
2020                                         btc8723b2ant_ps_tdma(btcoexist,
2021                                                              NORMAL_EXEC,
2022                                                              true, 5);
2023                                         coex_dm->ps_tdma_du_adj_type = 5;
2024                                 } else if (coex_dm->cur_ps_tdma == 2) {
2025                                         btc8723b2ant_ps_tdma(btcoexist,
2026                                                              NORMAL_EXEC,
2027                                                              true, 6);
2028                                         coex_dm->ps_tdma_du_adj_type = 6;
2029                                 } else if (coex_dm->cur_ps_tdma == 3) {
2030                                         btc8723b2ant_ps_tdma(btcoexist,
2031                                                              NORMAL_EXEC,
2032                                                              true, 7);
2033                                         coex_dm->ps_tdma_du_adj_type = 7;
2034                                 } else if (coex_dm->cur_ps_tdma == 4) {
2035                                         btc8723b2ant_ps_tdma(btcoexist,
2036                                                              NORMAL_EXEC,
2037                                                              true, 8);
2038                                         coex_dm->ps_tdma_du_adj_type = 8;
2039                                 }
2040                                 if (coex_dm->cur_ps_tdma == 9) {
2041                                         btc8723b2ant_ps_tdma(btcoexist,
2042                                                              NORMAL_EXEC,
2043                                                              true, 13);
2044                                         coex_dm->ps_tdma_du_adj_type = 13;
2045                                 } else if (coex_dm->cur_ps_tdma == 10) {
2046                                         btc8723b2ant_ps_tdma(btcoexist,
2047                                                              NORMAL_EXEC,
2048                                                              true, 14);
2049                                         coex_dm->ps_tdma_du_adj_type = 14;
2050                                 } else if (coex_dm->cur_ps_tdma == 11) {
2051                                         btc8723b2ant_ps_tdma(btcoexist,
2052                                                              NORMAL_EXEC,
2053                                                              true, 15);
2054                                         coex_dm->ps_tdma_du_adj_type = 15;
2055                                 } else if (coex_dm->cur_ps_tdma == 12) {
2056                                         btc8723b2ant_ps_tdma(btcoexist,
2057                                                              NORMAL_EXEC,
2058                                                              true, 16);
2059                                         coex_dm->ps_tdma_du_adj_type = 16;
2060                                 }
2061
2062                                 if (result == -1) {
2063                                         if (coex_dm->cur_ps_tdma == 5) {
2064                                                 btc8723b2ant_ps_tdma(
2065                                                         btcoexist, NORMAL_EXEC,
2066                                                         true, 6);
2067                                                 coex_dm->ps_tdma_du_adj_type =
2068                                                         6;
2069                                         } else if (coex_dm->cur_ps_tdma == 6) {
2070                                                 btc8723b2ant_ps_tdma(
2071                                                         btcoexist, NORMAL_EXEC,
2072                                                         true, 7);
2073                                                 coex_dm->ps_tdma_du_adj_type =
2074                                                         7;
2075                                         } else if (coex_dm->cur_ps_tdma == 7) {
2076                                                 btc8723b2ant_ps_tdma(
2077                                                         btcoexist, NORMAL_EXEC,
2078                                                         true, 8);
2079                                                 coex_dm->ps_tdma_du_adj_type =
2080                                                         8;
2081                                         } else if (coex_dm->cur_ps_tdma == 13) {
2082                                                 btc8723b2ant_ps_tdma(
2083                                                         btcoexist, NORMAL_EXEC,
2084                                                         true, 14);
2085                                                 coex_dm->ps_tdma_du_adj_type =
2086                                                         14;
2087                                         } else if (coex_dm->cur_ps_tdma == 14) {
2088                                                 btc8723b2ant_ps_tdma(
2089                                                         btcoexist, NORMAL_EXEC,
2090                                                         true, 15);
2091                                                 coex_dm->ps_tdma_du_adj_type =
2092                                                         15;
2093                                         } else if (coex_dm->cur_ps_tdma == 15) {
2094                                                 btc8723b2ant_ps_tdma(
2095                                                         btcoexist, NORMAL_EXEC,
2096                                                         true, 16);
2097                                                 coex_dm->ps_tdma_du_adj_type =
2098                                                         16;
2099                                         }
2100                                 } else if (result == 1) {
2101                                         if (coex_dm->cur_ps_tdma == 8) {
2102                                                 btc8723b2ant_ps_tdma(
2103                                                         btcoexist, NORMAL_EXEC,
2104                                                         true, 7);
2105                                                 coex_dm->ps_tdma_du_adj_type =
2106                                                         7;
2107                                         } else if (coex_dm->cur_ps_tdma == 7) {
2108                                                 btc8723b2ant_ps_tdma(
2109                                                         btcoexist, NORMAL_EXEC,
2110                                                         true, 6);
2111                                                 coex_dm->ps_tdma_du_adj_type =
2112                                                         6;
2113                                         } else if (coex_dm->cur_ps_tdma == 6) {
2114                                                 btc8723b2ant_ps_tdma(
2115                                                         btcoexist, NORMAL_EXEC,
2116                                                         true, 5);
2117                                                 coex_dm->ps_tdma_du_adj_type =
2118                                                         5;
2119                                         } else if (coex_dm->cur_ps_tdma == 16) {
2120                                                 btc8723b2ant_ps_tdma(
2121                                                         btcoexist, NORMAL_EXEC,
2122                                                         true, 15);
2123                                                 coex_dm->ps_tdma_du_adj_type =
2124                                                         15;
2125                                         } else if (coex_dm->cur_ps_tdma == 15) {
2126                                                 btc8723b2ant_ps_tdma(
2127                                                         btcoexist, NORMAL_EXEC,
2128                                                         true, 14);
2129                                                 coex_dm->ps_tdma_du_adj_type =
2130                                                         14;
2131                                         } else if (coex_dm->cur_ps_tdma == 14) {
2132                                                 btc8723b2ant_ps_tdma(
2133                                                         btcoexist, NORMAL_EXEC,
2134                                                         true, 13);
2135                                                 coex_dm->ps_tdma_du_adj_type =
2136                                                         13;
2137                                         }
2138                                 }
2139                         } else {
2140                                 if (coex_dm->cur_ps_tdma == 5) {
2141                                         btc8723b2ant_ps_tdma(btcoexist,
2142                                                              NORMAL_EXEC,
2143                                                              true, 71);
2144                                         coex_dm->ps_tdma_du_adj_type = 71;
2145                                 } else if (coex_dm->cur_ps_tdma == 6) {
2146                                         btc8723b2ant_ps_tdma(btcoexist,
2147                                                              NORMAL_EXEC,
2148                                                              true, 2);
2149                                         coex_dm->ps_tdma_du_adj_type = 2;
2150                                 } else if (coex_dm->cur_ps_tdma == 7) {
2151                                         btc8723b2ant_ps_tdma(btcoexist,
2152                                                              NORMAL_EXEC,
2153                                                              true, 3);
2154                                         coex_dm->ps_tdma_du_adj_type = 3;
2155                                 } else if (coex_dm->cur_ps_tdma == 8) {
2156                                         btc8723b2ant_ps_tdma(btcoexist,
2157                                                              NORMAL_EXEC,
2158                                                              true, 4);
2159                                         coex_dm->ps_tdma_du_adj_type = 4;
2160                                 }
2161                                 if (coex_dm->cur_ps_tdma == 13) {
2162                                         btc8723b2ant_ps_tdma(btcoexist,
2163                                                              NORMAL_EXEC,
2164                                                              true, 9);
2165                                         coex_dm->ps_tdma_du_adj_type = 9;
2166                                 } else if (coex_dm->cur_ps_tdma == 14) {
2167                                         btc8723b2ant_ps_tdma(btcoexist,
2168                                                              NORMAL_EXEC,
2169                                                              true, 10);
2170                                         coex_dm->ps_tdma_du_adj_type = 10;
2171                                 } else if (coex_dm->cur_ps_tdma == 15) {
2172                                         btc8723b2ant_ps_tdma(btcoexist,
2173                                                              NORMAL_EXEC,
2174                                                              true, 11);
2175                                         coex_dm->ps_tdma_du_adj_type = 11;
2176                                 } else if (coex_dm->cur_ps_tdma == 16) {
2177                                         btc8723b2ant_ps_tdma(btcoexist,
2178                                                              NORMAL_EXEC,
2179                                                              true, 12);
2180                                         coex_dm->ps_tdma_du_adj_type = 12;
2181                                 }
2182
2183                                 if (result == -1) {
2184                                         if (coex_dm->cur_ps_tdma == 71) {
2185                                                 btc8723b2ant_ps_tdma(
2186                                                         btcoexist, NORMAL_EXEC,
2187                                                         true, 1);
2188                                                 coex_dm->ps_tdma_du_adj_type =
2189                                                         1;
2190                                         } else if (coex_dm->cur_ps_tdma == 1) {
2191                                                 btc8723b2ant_ps_tdma(
2192                                                         btcoexist, NORMAL_EXEC,
2193                                                         true, 2);
2194                                                 coex_dm->ps_tdma_du_adj_type =
2195                                                         2;
2196                                         } else if (coex_dm->cur_ps_tdma == 2) {
2197                                                 btc8723b2ant_ps_tdma(
2198                                                         btcoexist, NORMAL_EXEC,
2199                                                         true, 3);
2200                                                 coex_dm->ps_tdma_du_adj_type =
2201                                                         3;
2202                                         } else if (coex_dm->cur_ps_tdma == 3) {
2203                                                 btc8723b2ant_ps_tdma(
2204                                                         btcoexist, NORMAL_EXEC,
2205                                                         true, 4);
2206                                                 coex_dm->ps_tdma_du_adj_type =
2207                                                         4;
2208                                         } else if (coex_dm->cur_ps_tdma == 9) {
2209                                                 btc8723b2ant_ps_tdma(
2210                                                         btcoexist, NORMAL_EXEC,
2211                                                         true, 10);
2212                                                 coex_dm->ps_tdma_du_adj_type =
2213                                                         10;
2214                                         } else if (coex_dm->cur_ps_tdma == 10) {
2215                                                 btc8723b2ant_ps_tdma(
2216                                                         btcoexist, NORMAL_EXEC,
2217                                                         true, 11);
2218                                                 coex_dm->ps_tdma_du_adj_type =
2219                                                         11;
2220                                         } else if (coex_dm->cur_ps_tdma == 11) {
2221                                                 btc8723b2ant_ps_tdma(
2222                                                         btcoexist, NORMAL_EXEC,
2223                                                         true, 12);
2224                                                 coex_dm->ps_tdma_du_adj_type =
2225                                                         12;
2226                                         }
2227                                 } else if (result == 1) {
2228                                         if (coex_dm->cur_ps_tdma == 4) {
2229                                                 btc8723b2ant_ps_tdma(
2230                                                         btcoexist, NORMAL_EXEC,
2231                                                         true, 3);
2232                                                 coex_dm->ps_tdma_du_adj_type =
2233                                                         3;
2234                                         } else if (coex_dm->cur_ps_tdma == 3) {
2235                                                 btc8723b2ant_ps_tdma(
2236                                                         btcoexist, NORMAL_EXEC,
2237                                                         true, 2);
2238                                                 coex_dm->ps_tdma_du_adj_type =
2239                                                         2;
2240                                         } else if (coex_dm->cur_ps_tdma == 2) {
2241                                                 btc8723b2ant_ps_tdma(
2242                                                         btcoexist, NORMAL_EXEC,
2243                                                         true, 1);
2244                                                 coex_dm->ps_tdma_du_adj_type =
2245                                                         1;
2246                                         } else if (coex_dm->cur_ps_tdma == 1) {
2247                                                 btc8723b2ant_ps_tdma(
2248                                                         btcoexist, NORMAL_EXEC,
2249                                                         true, 71);
2250                                                 coex_dm->ps_tdma_du_adj_type =
2251                                                         71;
2252                                         } else if (coex_dm->cur_ps_tdma == 12) {
2253                                                 btc8723b2ant_ps_tdma(
2254                                                         btcoexist, NORMAL_EXEC,
2255                                                         true, 11);
2256                                                 coex_dm->ps_tdma_du_adj_type =
2257                                                         11;
2258                                         } else if (coex_dm->cur_ps_tdma == 11) {
2259                                                 btc8723b2ant_ps_tdma(
2260                                                         btcoexist, NORMAL_EXEC,
2261                                                         true, 10);
2262                                                 coex_dm->ps_tdma_du_adj_type =
2263                                                         10;
2264                                         } else if (coex_dm->cur_ps_tdma == 10) {
2265                                                 btc8723b2ant_ps_tdma(
2266                                                         btcoexist, NORMAL_EXEC,
2267                                                         true, 9);
2268                                                 coex_dm->ps_tdma_du_adj_type =
2269                                                         9;
2270                                         }
2271                                 }
2272                         }
2273                 } else if (max_interval == 2) {
2274                         if (tx_pause) {
2275                                 if (coex_dm->cur_ps_tdma == 1) {
2276                                         btc8723b2ant_ps_tdma(btcoexist,
2277                                                              NORMAL_EXEC,
2278                                                              true, 6);
2279                                         coex_dm->ps_tdma_du_adj_type = 6;
2280                                 } else if (coex_dm->cur_ps_tdma == 2) {
2281                                         btc8723b2ant_ps_tdma(btcoexist,
2282                                                              NORMAL_EXEC,
2283                                                              true, 6);
2284                                         coex_dm->ps_tdma_du_adj_type = 6;
2285                                 } else if (coex_dm->cur_ps_tdma == 3) {
2286                                         btc8723b2ant_ps_tdma(btcoexist,
2287                                                              NORMAL_EXEC,
2288                                                              true, 7);
2289                                         coex_dm->ps_tdma_du_adj_type = 7;
2290                                 } else if (coex_dm->cur_ps_tdma == 4) {
2291                                         btc8723b2ant_ps_tdma(btcoexist,
2292                                                              NORMAL_EXEC,
2293                                                              true, 8);
2294                                         coex_dm->ps_tdma_du_adj_type = 8;
2295                                 }
2296                                 if (coex_dm->cur_ps_tdma == 9) {
2297                                         btc8723b2ant_ps_tdma(btcoexist,
2298                                                              NORMAL_EXEC,
2299                                                              true, 14);
2300                                         coex_dm->ps_tdma_du_adj_type = 14;
2301                                 } else if (coex_dm->cur_ps_tdma == 10) {
2302                                         btc8723b2ant_ps_tdma(btcoexist,
2303                                                              NORMAL_EXEC,
2304                                                              true, 14);
2305                                         coex_dm->ps_tdma_du_adj_type = 14;
2306                                 } else if (coex_dm->cur_ps_tdma == 11) {
2307                                         btc8723b2ant_ps_tdma(btcoexist,
2308                                                              NORMAL_EXEC,
2309                                                              true, 15);
2310                                         coex_dm->ps_tdma_du_adj_type = 15;
2311                                 } else if (coex_dm->cur_ps_tdma == 12) {
2312                                         btc8723b2ant_ps_tdma(btcoexist,
2313                                                              NORMAL_EXEC,
2314                                                              true, 16);
2315                                         coex_dm->ps_tdma_du_adj_type = 16;
2316                                 }
2317                                 if (result == -1) {
2318                                         if (coex_dm->cur_ps_tdma == 5) {
2319                                                 btc8723b2ant_ps_tdma(
2320                                                         btcoexist, NORMAL_EXEC,
2321                                                         true, 6);
2322                                                 coex_dm->ps_tdma_du_adj_type =
2323                                                         6;
2324                                         } else if (coex_dm->cur_ps_tdma == 6) {
2325                                                 btc8723b2ant_ps_tdma(
2326                                                         btcoexist, NORMAL_EXEC,
2327                                                         true, 7);
2328                                                 coex_dm->ps_tdma_du_adj_type =
2329                                                         7;
2330                                         } else if (coex_dm->cur_ps_tdma == 7) {
2331                                                 btc8723b2ant_ps_tdma(
2332                                                         btcoexist, NORMAL_EXEC,
2333                                                         true, 8);
2334                                                 coex_dm->ps_tdma_du_adj_type =
2335                                                         8;
2336                                         } else if (coex_dm->cur_ps_tdma == 13) {
2337                                                 btc8723b2ant_ps_tdma(
2338                                                         btcoexist, NORMAL_EXEC,
2339                                                         true, 14);
2340                                                 coex_dm->ps_tdma_du_adj_type =
2341                                                         14;
2342                                         } else if (coex_dm->cur_ps_tdma == 14) {
2343                                                 btc8723b2ant_ps_tdma(
2344                                                         btcoexist, NORMAL_EXEC,
2345                                                         true, 15);
2346                                                 coex_dm->ps_tdma_du_adj_type =
2347                                                         15;
2348                                         } else if (coex_dm->cur_ps_tdma == 15) {
2349                                                 btc8723b2ant_ps_tdma(
2350                                                         btcoexist, NORMAL_EXEC,
2351                                                         true, 16);
2352                                                 coex_dm->ps_tdma_du_adj_type =
2353                                                         16;
2354                                         }
2355                                 } else if (result == 1) {
2356                                         if (coex_dm->cur_ps_tdma == 8) {
2357                                                 btc8723b2ant_ps_tdma(
2358                                                         btcoexist, NORMAL_EXEC,
2359                                                         true, 7);
2360                                                 coex_dm->ps_tdma_du_adj_type =
2361                                                         7;
2362                                         } else if (coex_dm->cur_ps_tdma == 7) {
2363                                                 btc8723b2ant_ps_tdma(
2364                                                         btcoexist, NORMAL_EXEC,
2365                                                         true, 6);
2366                                                 coex_dm->ps_tdma_du_adj_type =
2367                                                         6;
2368                                         } else if (coex_dm->cur_ps_tdma == 6) {
2369                                                 btc8723b2ant_ps_tdma(
2370                                                         btcoexist, NORMAL_EXEC,
2371                                                         true, 6);
2372                                                 coex_dm->ps_tdma_du_adj_type =
2373                                                         6;
2374                                         } else if (coex_dm->cur_ps_tdma == 16) {
2375                                                 btc8723b2ant_ps_tdma(
2376                                                         btcoexist, NORMAL_EXEC,
2377                                                         true, 15);
2378                                                 coex_dm->ps_tdma_du_adj_type =
2379                                                         15;
2380                                         } else if (coex_dm->cur_ps_tdma == 15) {
2381                                                 btc8723b2ant_ps_tdma(
2382                                                         btcoexist, NORMAL_EXEC,
2383                                                         true, 14);
2384                                                 coex_dm->ps_tdma_du_adj_type =
2385                                                         14;
2386                                         } else if (coex_dm->cur_ps_tdma == 14) {
2387                                                 btc8723b2ant_ps_tdma(
2388                                                         btcoexist, NORMAL_EXEC,
2389                                                         true, 14);
2390                                                 coex_dm->ps_tdma_du_adj_type =
2391                                                         14;
2392                                         }
2393                                 }
2394                         } else {
2395                                 if (coex_dm->cur_ps_tdma == 5) {
2396                                         btc8723b2ant_ps_tdma(btcoexist,
2397                                                              NORMAL_EXEC,
2398                                                              true, 2);
2399                                         coex_dm->ps_tdma_du_adj_type = 2;
2400                                 } else if (coex_dm->cur_ps_tdma == 6) {
2401                                         btc8723b2ant_ps_tdma(btcoexist,
2402                                                              NORMAL_EXEC,
2403                                                              true, 2);
2404                                         coex_dm->ps_tdma_du_adj_type = 2;
2405                                 } else if (coex_dm->cur_ps_tdma == 7) {
2406                                         btc8723b2ant_ps_tdma(btcoexist,
2407                                                              NORMAL_EXEC,
2408                                                              true, 3);
2409                                         coex_dm->ps_tdma_du_adj_type = 3;
2410                                 } else if (coex_dm->cur_ps_tdma == 8) {
2411                                         btc8723b2ant_ps_tdma(btcoexist,
2412                                                              NORMAL_EXEC,
2413                                                              true, 4);
2414                                         coex_dm->ps_tdma_du_adj_type = 4;
2415                                 }
2416                                 if (coex_dm->cur_ps_tdma == 13) {
2417                                         btc8723b2ant_ps_tdma(btcoexist,
2418                                                              NORMAL_EXEC,
2419                                                              true, 10);
2420                                         coex_dm->ps_tdma_du_adj_type = 10;
2421                                 } else if (coex_dm->cur_ps_tdma == 14) {
2422                                         btc8723b2ant_ps_tdma(btcoexist,
2423                                                              NORMAL_EXEC,
2424                                                              true, 10);
2425                                         coex_dm->ps_tdma_du_adj_type = 10;
2426                                 } else if (coex_dm->cur_ps_tdma == 15) {
2427                                         btc8723b2ant_ps_tdma(btcoexist,
2428                                                              NORMAL_EXEC,
2429                                                              true, 11);
2430                                         coex_dm->ps_tdma_du_adj_type = 11;
2431                                 } else if (coex_dm->cur_ps_tdma == 16) {
2432                                         btc8723b2ant_ps_tdma(btcoexist,
2433                                                              NORMAL_EXEC,
2434                                                              true, 12);
2435                                         coex_dm->ps_tdma_du_adj_type = 12;
2436                                 }
2437                                 if (result == -1) {
2438                                         if (coex_dm->cur_ps_tdma == 1) {
2439                                                 btc8723b2ant_ps_tdma(
2440                                                         btcoexist, NORMAL_EXEC,
2441                                                         true, 2);
2442                                                 coex_dm->ps_tdma_du_adj_type =
2443                                                         2;
2444                                         } else if (coex_dm->cur_ps_tdma == 2) {
2445                                                 btc8723b2ant_ps_tdma(
2446                                                         btcoexist, NORMAL_EXEC,
2447                                                         true, 3);
2448                                                 coex_dm->ps_tdma_du_adj_type =
2449                                                         3;
2450                                         } else if (coex_dm->cur_ps_tdma == 3) {
2451                                                 btc8723b2ant_ps_tdma(
2452                                                         btcoexist, NORMAL_EXEC,
2453                                                         true, 4);
2454                                                 coex_dm->ps_tdma_du_adj_type =
2455                                                         4;
2456                                         } else if (coex_dm->cur_ps_tdma == 9) {
2457                                                 btc8723b2ant_ps_tdma(
2458                                                         btcoexist, NORMAL_EXEC,
2459                                                         true, 10);
2460                                                 coex_dm->ps_tdma_du_adj_type =
2461                                                         10;
2462                                         } else if (coex_dm->cur_ps_tdma == 10) {
2463                                                 btc8723b2ant_ps_tdma(
2464                                                         btcoexist, NORMAL_EXEC,
2465                                                         true, 11);
2466                                                 coex_dm->ps_tdma_du_adj_type =
2467                                                         11;
2468                                         } else if (coex_dm->cur_ps_tdma == 11) {
2469                                                 btc8723b2ant_ps_tdma(
2470                                                         btcoexist, NORMAL_EXEC,
2471                                                         true, 12);
2472                                                 coex_dm->ps_tdma_du_adj_type =
2473                                                         12;
2474                                         }
2475                                 } else if (result == 1) {
2476                                         if (coex_dm->cur_ps_tdma == 4) {
2477                                                 btc8723b2ant_ps_tdma(
2478                                                         btcoexist, NORMAL_EXEC,
2479                                                         true, 3);
2480                                                 coex_dm->ps_tdma_du_adj_type =
2481                                                         3;
2482                                         } else if (coex_dm->cur_ps_tdma == 3) {
2483                                                 btc8723b2ant_ps_tdma(
2484                                                         btcoexist, NORMAL_EXEC,
2485                                                         true, 2);
2486                                                 coex_dm->ps_tdma_du_adj_type =
2487                                                         2;
2488                                         } else if (coex_dm->cur_ps_tdma == 2) {
2489                                                 btc8723b2ant_ps_tdma(
2490                                                         btcoexist, NORMAL_EXEC,
2491                                                         true, 2);
2492                                                 coex_dm->ps_tdma_du_adj_type =
2493                                                         2;
2494                                         } else if (coex_dm->cur_ps_tdma == 12) {
2495                                                 btc8723b2ant_ps_tdma(
2496                                                         btcoexist, NORMAL_EXEC,
2497                                                         true, 11);
2498                                                 coex_dm->ps_tdma_du_adj_type =
2499                                                         11;
2500                                         } else if (coex_dm->cur_ps_tdma == 11) {
2501                                                 btc8723b2ant_ps_tdma(
2502                                                         btcoexist, NORMAL_EXEC,
2503                                                         true, 10);
2504                                                 coex_dm->ps_tdma_du_adj_type =
2505                                                         10;
2506                                         } else if (coex_dm->cur_ps_tdma == 10) {
2507                                                 btc8723b2ant_ps_tdma(
2508                                                         btcoexist, NORMAL_EXEC,
2509                                                         true, 10);
2510                                                 coex_dm->ps_tdma_du_adj_type =
2511                                                         10;
2512                                         }
2513                                 }
2514                         }
2515                 } else if (max_interval == 3) {
2516                         if (tx_pause) {
2517                                 if (coex_dm->cur_ps_tdma == 1) {
2518                                         btc8723b2ant_ps_tdma(btcoexist,
2519                                                              NORMAL_EXEC,
2520                                                              true, 7);
2521                                         coex_dm->ps_tdma_du_adj_type = 7;
2522                                 } else if (coex_dm->cur_ps_tdma == 2) {
2523                                         btc8723b2ant_ps_tdma(btcoexist,
2524                                                              NORMAL_EXEC,
2525                                                              true, 7);
2526                                         coex_dm->ps_tdma_du_adj_type = 7;
2527                                 } else if (coex_dm->cur_ps_tdma == 3) {
2528                                         btc8723b2ant_ps_tdma(btcoexist,
2529                                                              NORMAL_EXEC,
2530                                                              true, 7);
2531                                         coex_dm->ps_tdma_du_adj_type = 7;
2532                                 } else if (coex_dm->cur_ps_tdma == 4) {
2533                                         btc8723b2ant_ps_tdma(btcoexist,
2534                                                              NORMAL_EXEC,
2535                                                              true, 8);
2536                                         coex_dm->ps_tdma_du_adj_type = 8;
2537                                 }
2538                                 if (coex_dm->cur_ps_tdma == 9) {
2539                                         btc8723b2ant_ps_tdma(btcoexist,
2540                                                              NORMAL_EXEC,
2541                                                              true, 15);
2542                                         coex_dm->ps_tdma_du_adj_type = 15;
2543                                 } else if (coex_dm->cur_ps_tdma == 10) {
2544                                         btc8723b2ant_ps_tdma(btcoexist,
2545                                                              NORMAL_EXEC,
2546                                                              true, 15);
2547                                         coex_dm->ps_tdma_du_adj_type = 15;
2548                                 } else if (coex_dm->cur_ps_tdma == 11) {
2549                                         btc8723b2ant_ps_tdma(btcoexist,
2550                                                              NORMAL_EXEC,
2551                                                              true, 15);
2552                                         coex_dm->ps_tdma_du_adj_type = 15;
2553                                 } else if (coex_dm->cur_ps_tdma == 12) {
2554                                         btc8723b2ant_ps_tdma(btcoexist,
2555                                                              NORMAL_EXEC,
2556                                                              true, 16);
2557                                         coex_dm->ps_tdma_du_adj_type = 16;
2558                                 }
2559                                 if (result == -1) {
2560                                         if (coex_dm->cur_ps_tdma == 5) {
2561                                                 btc8723b2ant_ps_tdma(
2562                                                         btcoexist, NORMAL_EXEC,
2563                                                         true, 7);
2564                                                 coex_dm->ps_tdma_du_adj_type =
2565                                                         7;
2566                                         } else if (coex_dm->cur_ps_tdma == 6) {
2567                                                 btc8723b2ant_ps_tdma(
2568                                                         btcoexist, NORMAL_EXEC,
2569                                                         true, 7);
2570                                                 coex_dm->ps_tdma_du_adj_type =
2571                                                         7;
2572                                         } else if (coex_dm->cur_ps_tdma == 7) {
2573                                                 btc8723b2ant_ps_tdma(
2574                                                         btcoexist, NORMAL_EXEC,
2575                                                         true, 8);
2576                                                 coex_dm->ps_tdma_du_adj_type =
2577                                                         8;
2578                                         } else if (coex_dm->cur_ps_tdma == 13) {
2579                                                 btc8723b2ant_ps_tdma(
2580                                                         btcoexist, NORMAL_EXEC,
2581                                                         true, 15);
2582                                                 coex_dm->ps_tdma_du_adj_type =
2583                                                         15;
2584                                         } else if (coex_dm->cur_ps_tdma == 14) {
2585                                                 btc8723b2ant_ps_tdma(
2586                                                         btcoexist, NORMAL_EXEC,
2587                                                         true, 15);
2588                                                 coex_dm->ps_tdma_du_adj_type =
2589                                                         15;
2590                                         } else if (coex_dm->cur_ps_tdma == 15) {
2591                                                 btc8723b2ant_ps_tdma(
2592                                                         btcoexist, NORMAL_EXEC,
2593                                                         true, 16);
2594                                                 coex_dm->ps_tdma_du_adj_type =
2595                                                         16;
2596                                         }
2597                                 } else if (result == 1) {
2598                                         if (coex_dm->cur_ps_tdma == 8) {
2599                                                 btc8723b2ant_ps_tdma(
2600                                                         btcoexist, NORMAL_EXEC,
2601                                                         true, 7);
2602                                                 coex_dm->ps_tdma_du_adj_type =
2603                                                         7;
2604                                         } else if (coex_dm->cur_ps_tdma == 7) {
2605                                                 btc8723b2ant_ps_tdma(
2606                                                         btcoexist, NORMAL_EXEC,
2607                                                         true, 7);
2608                                                 coex_dm->ps_tdma_du_adj_type =
2609                                                         7;
2610                                         } else if (coex_dm->cur_ps_tdma == 6) {
2611                                                 btc8723b2ant_ps_tdma(
2612                                                         btcoexist, NORMAL_EXEC,
2613                                                         true, 7);
2614                                                 coex_dm->ps_tdma_du_adj_type =
2615                                                         7;
2616                                         } else if (coex_dm->cur_ps_tdma == 16) {
2617                                                 btc8723b2ant_ps_tdma(
2618                                                         btcoexist, NORMAL_EXEC,
2619                                                         true, 15);
2620                                                 coex_dm->ps_tdma_du_adj_type =
2621                                                         15;
2622                                         } else if (coex_dm->cur_ps_tdma == 15) {
2623                                                 btc8723b2ant_ps_tdma(
2624                                                         btcoexist, NORMAL_EXEC,
2625                                                         true, 15);
2626                                                 coex_dm->ps_tdma_du_adj_type =
2627                                                         15;
2628                                         } else if (coex_dm->cur_ps_tdma == 14) {
2629                                                 btc8723b2ant_ps_tdma(
2630                                                         btcoexist, NORMAL_EXEC,
2631                                                         true, 15);
2632                                                 coex_dm->ps_tdma_du_adj_type =
2633                                                         15;
2634                                         }
2635                                 }
2636                         } else {
2637                                 if (coex_dm->cur_ps_tdma == 5) {
2638                                         btc8723b2ant_ps_tdma(btcoexist,
2639                                                              NORMAL_EXEC,
2640                                                              true, 3);
2641                                         coex_dm->ps_tdma_du_adj_type = 3;
2642                                 } else if (coex_dm->cur_ps_tdma == 6) {
2643                                         btc8723b2ant_ps_tdma(btcoexist,
2644                                                              NORMAL_EXEC,
2645                                                              true, 3);
2646                                         coex_dm->ps_tdma_du_adj_type = 3;
2647                                 } else if (coex_dm->cur_ps_tdma == 7) {
2648                                         btc8723b2ant_ps_tdma(btcoexist,
2649                                                              NORMAL_EXEC,
2650                                                              true, 3);
2651                                         coex_dm->ps_tdma_du_adj_type = 3;
2652                                 } else if (coex_dm->cur_ps_tdma == 8) {
2653                                         btc8723b2ant_ps_tdma(btcoexist,
2654                                                              NORMAL_EXEC,
2655                                                              true, 4);
2656                                         coex_dm->ps_tdma_du_adj_type = 4;
2657                                 }
2658                                 if (coex_dm->cur_ps_tdma == 13) {
2659                                         btc8723b2ant_ps_tdma(btcoexist,
2660                                                              NORMAL_EXEC,
2661                                                              true, 11);
2662                                         coex_dm->ps_tdma_du_adj_type = 11;
2663                                 } else if (coex_dm->cur_ps_tdma == 14) {
2664                                         btc8723b2ant_ps_tdma(btcoexist,
2665                                                              NORMAL_EXEC,
2666                                                              true, 11);
2667                                         coex_dm->ps_tdma_du_adj_type = 11;
2668                                 } else if (coex_dm->cur_ps_tdma == 15) {
2669                                         btc8723b2ant_ps_tdma(btcoexist,
2670                                                              NORMAL_EXEC,
2671                                                              true, 11);
2672                                         coex_dm->ps_tdma_du_adj_type = 11;
2673                                 } else if (coex_dm->cur_ps_tdma == 16) {
2674                                         btc8723b2ant_ps_tdma(btcoexist,
2675                                                              NORMAL_EXEC,
2676                                                              true, 12);
2677                                         coex_dm->ps_tdma_du_adj_type = 12;
2678                                 }
2679                                 if (result == -1) {
2680                                         if (coex_dm->cur_ps_tdma == 1) {
2681                                                 btc8723b2ant_ps_tdma(
2682                                                         btcoexist, NORMAL_EXEC,
2683                                                         true, 3);
2684                                                 coex_dm->ps_tdma_du_adj_type =
2685                                                         3;
2686                                         } else if (coex_dm->cur_ps_tdma == 2) {
2687                                                 btc8723b2ant_ps_tdma(
2688                                                         btcoexist, NORMAL_EXEC,
2689                                                         true, 3);
2690                                                 coex_dm->ps_tdma_du_adj_type =
2691                                                         3;
2692                                         } else if (coex_dm->cur_ps_tdma == 3) {
2693                                                 btc8723b2ant_ps_tdma(
2694                                                         btcoexist, NORMAL_EXEC,
2695                                                         true, 4);
2696                                                 coex_dm->ps_tdma_du_adj_type =
2697                                                         4;
2698                                         } else if (coex_dm->cur_ps_tdma == 9) {
2699                                                 btc8723b2ant_ps_tdma(
2700                                                         btcoexist, NORMAL_EXEC,
2701                                                         true, 11);
2702                                                 coex_dm->ps_tdma_du_adj_type =
2703                                                         11;
2704                                         } else if (coex_dm->cur_ps_tdma == 10) {
2705                                                 btc8723b2ant_ps_tdma(
2706                                                         btcoexist, NORMAL_EXEC,
2707                                                         true, 11);
2708                                                 coex_dm->ps_tdma_du_adj_type =
2709                                                         11;
2710                                         } else if (coex_dm->cur_ps_tdma == 11) {
2711                                                 btc8723b2ant_ps_tdma(
2712                                                         btcoexist, NORMAL_EXEC,
2713                                                         true, 12);
2714                                                 coex_dm->ps_tdma_du_adj_type =
2715                                                         12;
2716                                         }
2717                                 } else if (result == 1) {
2718                                         if (coex_dm->cur_ps_tdma == 4) {
2719                                                 btc8723b2ant_ps_tdma(
2720                                                         btcoexist, NORMAL_EXEC,
2721                                                         true, 3);
2722                                                 coex_dm->ps_tdma_du_adj_type =
2723                                                         3;
2724                                         } else if (coex_dm->cur_ps_tdma == 3) {
2725                                                 btc8723b2ant_ps_tdma(
2726                                                         btcoexist, NORMAL_EXEC,
2727                                                         true, 3);
2728                                                 coex_dm->ps_tdma_du_adj_type =
2729                                                         3;
2730                                         } else if (coex_dm->cur_ps_tdma == 2) {
2731                                                 btc8723b2ant_ps_tdma(
2732                                                         btcoexist, NORMAL_EXEC,
2733                                                         true, 3);
2734                                                 coex_dm->ps_tdma_du_adj_type =
2735                                                         3;
2736                                         } else if (coex_dm->cur_ps_tdma == 12) {
2737                                                 btc8723b2ant_ps_tdma(
2738                                                         btcoexist, NORMAL_EXEC,
2739                                                         true, 11);
2740                                                 coex_dm->ps_tdma_du_adj_type =
2741                                                         11;
2742                                         } else if (coex_dm->cur_ps_tdma == 11) {
2743                                                 btc8723b2ant_ps_tdma(
2744                                                         btcoexist, NORMAL_EXEC,
2745                                                         true, 11);
2746                                                 coex_dm->ps_tdma_du_adj_type =
2747                                                         11;
2748                                         } else if (coex_dm->cur_ps_tdma == 10) {
2749                                                 btc8723b2ant_ps_tdma(
2750                                                         btcoexist, NORMAL_EXEC,
2751                                                         true, 11);
2752                                                 coex_dm->ps_tdma_du_adj_type =
2753                                                         11;
2754                                         }
2755                                 }
2756                         }
2757                 }
2758         }
2759
2760         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2761                  "[BTCoex], max Interval = %d\n", max_interval);
2762
2763         /* if current PsTdma not match with the recorded one (scan, dhcp, ...),
2764          * then we have to adjust it back to the previous recorded one.
2765          */
2766         if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2767                 bool scan = false, link = false, roam = false;
2768                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2769                          "[BTCoex], PsTdma type dismatch!!!, curPsTdma=%d, recordPsTdma=%d\n",
2770                          coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2771
2772                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2773                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2774                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2775
2776                 if (!scan && !link && !roam)
2777                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2778                                              coex_dm->ps_tdma_du_adj_type);
2779                 else
2780                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2781                                  "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2782         }
2783 }
2784
2785 /* SCO only or SCO+PAN(HS) */
2786 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2787 {
2788         u8 wifi_rssi_state, bt_rssi_state;
2789         u32 wifi_bw;
2790
2791         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2792         bt_rssi_state = btc8723b2ant_bt_rssi_state(
2793                 btcoexist, 2, BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2794                                                coex_dm->switch_thres_offset,
2795                 0);
2796
2797         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2798
2799         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2800         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2801
2802         if (BTC_RSSI_HIGH(bt_rssi_state))
2803                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2804         else
2805                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2806
2807         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2808
2809         if (BTC_WIFI_BW_LEGACY == wifi_bw)
2810                 /* for SCO quality at 11b/g mode */
2811                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2812         else
2813                 /* for SCO quality & wifi performance balance at 11n mode */
2814                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2815
2816         /* for voice quality */
2817         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2818
2819         /* sw mechanism */
2820         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2821                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2822                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2823                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
2824                                                   false, false);
2825                 } else {
2826                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
2827                                                   false, false);
2828                 }
2829         } else {
2830                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2831                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2832                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
2833                                                   false, false);
2834                 } else {
2835                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
2836                                                   false, false);
2837                 }
2838         }
2839 }
2840
2841 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2842 {
2843         u8 wifi_rssi_state, bt_rssi_state;
2844         u32 wifi_bw;
2845         u8 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2846                         coex_dm->switch_thres_offset;
2847
2848         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2849         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2850
2851         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2852
2853         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2854         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2855
2856         if (BTC_RSSI_HIGH(bt_rssi_state))
2857                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2858         else
2859                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2860
2861         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2862
2863         if (wifi_bw == BTC_WIFI_BW_LEGACY)
2864                 /* for HID at 11b/g mode */
2865                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2866         else
2867                 /* for HID quality & wifi performance balance at 11n mode */
2868                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 9);
2869
2870         btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2871
2872         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2873             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2874                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2875         else
2876                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2877
2878         /* sw mechanism */
2879         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2880                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2881                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2882                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
2883                                                   false, false);
2884                 } else {
2885                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
2886                                                   false, false);
2887                 }
2888         } else {
2889                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2890                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2891                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
2892                                                   false, false);
2893                 } else {
2894                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
2895                                                   false, false);
2896                 }
2897         }
2898 }
2899
2900 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2901 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2902 {
2903         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2904         u32 wifi_bw;
2905         u8 ap_num = 0;
2906         u8 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2907                         coex_dm->switch_thres_offset;
2908
2909         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2910         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2, 40, 0);
2911         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2912
2913         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
2914
2915         /* define the office environment */
2916         /* driver don't know AP num in Linux, so we will never enter this if */
2917         if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) {
2918                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2919                                           0x0);
2920                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2921                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2922                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2923                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2924
2925                 /* sw mechanism */
2926                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2927                 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2928                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
2929                                                   false, false);
2930                 } else {
2931                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
2932                                                   false, false);
2933                 }
2934                 return;
2935         }
2936
2937         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2938         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2939
2940         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2941
2942         if (BTC_RSSI_HIGH(bt_rssi_state))
2943                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2944         else
2945                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2946
2947         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2948                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2949                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2950                                               0x0, 0x0);
2951         } else {
2952                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2953                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2954                                               0x4);
2955         }
2956
2957         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2958             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2959                 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2960                                                   false, 1);
2961         else
2962                 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2963
2964         /* sw mechanism */
2965         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2966         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2967                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2968                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2969                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
2970                                                   false, false);
2971                 } else {
2972                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
2973                                                   false, false);
2974                 }
2975         } else {
2976                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2977                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2978                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
2979                                                   false, false);
2980                 } else {
2981                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
2982                                                   false, false);
2983                 }
2984         }
2985 }
2986
2987 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2988 {
2989         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2990         u32 wifi_bw;
2991         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
2992                         coex_dm->switch_thres_offset;
2993
2994         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2995         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
2996                                                         tmp, 0);
2997         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2998                         coex_dm->switch_thres_offset;
2999         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3000
3001         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3002
3003         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3004         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3005
3006         if (BTC_RSSI_HIGH(bt_rssi_state))
3007                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3008         else
3009                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3010
3011         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3012                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3013                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3014                                               0x0, 0x0);
3015         } else {
3016                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3017                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3018                                               0x4);
3019         }
3020
3021         btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
3022
3023         /* sw mechanism */
3024         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3025         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3026                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3027                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3028                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3029                                                   false, false);
3030                 } else {
3031                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3032                                                   false, false);
3033                 }
3034         } else {
3035                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3036                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3037                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3038                                                   false, false);
3039                 } else {
3040                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3041                                                   false, false);
3042                 }
3043         }
3044 }
3045
3046 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
3047 {
3048         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3049         u32 wifi_bw;
3050         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3051                         coex_dm->switch_thres_offset;
3052
3053         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3054         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3055                                                         tmp, 0);
3056         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3057                         coex_dm->switch_thres_offset;
3058         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3059
3060         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3061
3062         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3063         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3064
3065         if (BTC_RSSI_HIGH(bt_rssi_state))
3066                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3067         else
3068                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3069
3070         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3071                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 10);
3072                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3073                                               0x0, 0x0);
3074         } else {
3075                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3076                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3077                                               0x4);
3078         }
3079
3080         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3081             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
3082                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
3083         else
3084                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
3085
3086         /* sw mechanism */
3087         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3088         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3089                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3090                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3091                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3092                                                   false, false);
3093                 } else {
3094                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3095                                                   false, false);
3096                 }
3097         } else {
3098                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3099                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3100                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3101                                                   false, false);
3102                 } else {
3103                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3104                                                   false, false);
3105                 }
3106         }
3107 }
3108
3109 /* PAN(HS) only */
3110 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
3111 {
3112         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3113         u32 wifi_bw;
3114         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3115                         coex_dm->switch_thres_offset;
3116
3117         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3118         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3119                                                         tmp, 0);
3120         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3121                         coex_dm->switch_thres_offset;
3122         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3123
3124         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3125
3126         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3127         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3128
3129         if (BTC_RSSI_HIGH(bt_rssi_state))
3130                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3131         else
3132                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3133
3134         btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3135         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3136
3137         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3138         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3139                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3140                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3141                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3142                                                   false, false);
3143                 } else {
3144                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3145                                                   false, false);
3146                 }
3147         } else {
3148                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3149                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3150                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3151                                                   false, false);
3152                 } else {
3153                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3154                                                   false, false);
3155                 }
3156         }
3157 }
3158
3159 /* PAN(EDR) + A2DP */
3160 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
3161 {
3162         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3163         u32 wifi_bw;
3164         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3165                         coex_dm->switch_thres_offset;
3166
3167         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3168         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3169                                                         tmp, 0);
3170         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3171                         coex_dm->switch_thres_offset;
3172         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3173
3174         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3175
3176         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3177
3178         if (BTC_RSSI_HIGH(bt_rssi_state))
3179                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3180         else
3181                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3182
3183         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state))
3184                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3185                                               0x0, 0x0);
3186         else
3187                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3188                                               0x4);
3189         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3190
3191         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3192             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3193                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
3194                 if (BTC_WIFI_BW_HT40 == wifi_bw)
3195                         btc8723b2ant_tdma_duration_adjust(btcoexist, false,
3196                                                           true, 3);
3197                 else
3198                         btc8723b2ant_tdma_duration_adjust(btcoexist, false,
3199                                                           false, 3);
3200         } else {
3201                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3202                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
3203         }
3204
3205         /* sw mechanism */
3206         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3207                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3208                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3209                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3210                                                   false, false);
3211                 } else {
3212                         btc8723b2ant_sw_mechanism(btcoexist, true, false,
3213                                                   false, false);
3214                 }
3215         } else {
3216                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3217                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3218                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3219                                                   false, false);
3220                 } else {
3221                         btc8723b2ant_sw_mechanism(btcoexist, false, false,
3222                                                   false, false);
3223                 }
3224         }
3225 }
3226
3227 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
3228 {
3229         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3230         u32 wifi_bw;
3231         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3232                         coex_dm->switch_thres_offset;
3233
3234         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3235         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3236                                                         tmp, 0);
3237         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3238                         coex_dm->switch_thres_offset;
3239         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3240         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3241
3242         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3243
3244         if (BTC_RSSI_HIGH(bt_rssi_state))
3245                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3246         else
3247                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3248
3249         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3250                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3251                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3252                                               0x0, 0x0);
3253         } else {
3254                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3255                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3256                                               0x4);
3257         }
3258
3259         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3260             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3261                 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3262                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3263                                                       3);
3264                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3265                                                   0xfffff, 0x780);
3266                 } else {
3267                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3268                                                       6);
3269                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3270                                                   0xfffff, 0x0);
3271                 }
3272                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
3273         } else {
3274                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3275                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
3276                                           0x0);
3277                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
3278         }
3279
3280         /* sw mechanism */
3281         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3282                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3283                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3284                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
3285                                                   false, false);
3286                 } else {
3287                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
3288                                                   false, false);
3289                 }
3290         } else {
3291                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3292                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3293                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
3294                                                   false, false);
3295                 } else {
3296                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
3297                                                   false, false);
3298                 }
3299         }
3300 }
3301
3302 /* HID + A2DP + PAN(EDR) */
3303 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
3304 {
3305         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3306         u32 wifi_bw;
3307         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3308                         coex_dm->switch_thres_offset;
3309
3310         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3311         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3312                                                         tmp, 0);
3313         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3314                         coex_dm->switch_thres_offset;
3315         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3316
3317         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3318
3319         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3320         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3321
3322         if (BTC_RSSI_HIGH(bt_rssi_state))
3323                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3324         else
3325                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3326
3327         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3328                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3329                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3330                                               0x0, 0x0);
3331         } else {
3332                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3333                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3334                                               0x4);
3335         }
3336
3337         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3338
3339
3340         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3341             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3342                 if (BTC_WIFI_BW_HT40 == wifi_bw)
3343                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3344                                                           true, 2);
3345                 else
3346                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3347                                                           false, 3);
3348         } else {
3349                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3350         }
3351
3352         /* sw mechanism */
3353         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3354                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3355                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3356                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
3357                                                   false, false);
3358                 } else {
3359                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
3360                                                   false, false);
3361                 }
3362         } else {
3363                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3364                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3365                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
3366                                                   false, false);
3367                 } else {
3368                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
3369                                                   false, false);
3370                 }
3371         }
3372 }
3373
3374 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3375 {
3376         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3377         u32 wifi_bw;
3378         u8 ap_num = 0;
3379         u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3380                         coex_dm->switch_thres_offset;
3381
3382         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3383         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3384                                                         tmp, 0);
3385         tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3386                          coex_dm->switch_thres_offset;
3387         bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 3, tmp, 37);
3388
3389         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3390
3391         btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3392         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3393
3394         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3395
3396         if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3397                 if (BTC_RSSI_HIGH(bt_rssi_state))
3398                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3399                 else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3400                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3401                 else
3402                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3403         } else {
3404                 /* only 802.11N mode we have to dec bt power to 4 degree */
3405                 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3406                         /* need to check ap Number of Not */
3407                         if (ap_num < 10)
3408                                 btc8723b2ant_dec_bt_pwr(btcoexist,
3409                                                         NORMAL_EXEC, 4);
3410                         else
3411                                 btc8723b2ant_dec_bt_pwr(btcoexist,
3412                                                         NORMAL_EXEC, 2);
3413                 } else if (BTC_RSSI_MEDIUM(bt_rssi_state)) {
3414                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3415                 } else {
3416                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3417                 }
3418         }
3419
3420         if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3421                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3422                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3423                                               0x0, 0x0);
3424         } else {
3425                 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3426                 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3427                                               0x4);
3428         }
3429
3430         if (BTC_RSSI_HIGH(bt_rssi_state)) {
3431                 if (ap_num < 10)
3432                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3433                                                           false, 1);
3434                 else
3435                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3436                                                           false, 3);
3437         } else {
3438                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 18);
3439                 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
3440                 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
3441                 btcoexist->btc_write_4byte(btcoexist, 0x430, 0x0);
3442                 btcoexist->btc_write_4byte(btcoexist, 0x434, 0x01010000);
3443
3444                 if (ap_num < 10)
3445                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3446                                                           true, 1);
3447                 else
3448                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3449                                                           true, 3);
3450         }
3451
3452         /* sw mechanism */
3453         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3454                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3455                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3456                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
3457                                                   false, false);
3458                 } else {
3459                         btc8723b2ant_sw_mechanism(btcoexist, true, true,
3460                                                   false, false);
3461                 }
3462         } else {
3463                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3464                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3465                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
3466                                                   false, false);
3467                 } else {
3468                         btc8723b2ant_sw_mechanism(btcoexist, false, true,
3469                                                   false, false);
3470                 }
3471         }
3472 }
3473
3474 static void btc8723b2ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
3475 {
3476         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3477         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3478
3479         /* sw all off */
3480         btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
3481
3482         /* hw all off */
3483         btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3484
3485         btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3486         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3487 }
3488
3489 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3490 {
3491         struct rtl_priv *rtlpriv = btcoexist->adapter;
3492         u8 algorithm = 0;
3493         u32 num_of_wifi_link = 0;
3494         u32 wifi_link_status = 0;
3495         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3496         bool miracast_plus_bt = false;
3497         bool scan = false, link = false, roam = false;
3498
3499         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3500                  "[BTCoex], RunCoexistMechanism()===>\n");
3501
3502         if (btcoexist->manual_control) {
3503                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3504                          "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3505                 return;
3506         }
3507
3508         if (coex_sta->under_ips) {
3509                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3510                          "[BTCoex], wifi is under IPS !!!\n");
3511                 return;
3512         }
3513
3514         algorithm = btc8723b2ant_action_algorithm(btcoexist);
3515         if (coex_sta->c2h_bt_inquiry_page &&
3516             (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
3517                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3518                          "[BTCoex], BT is under inquiry/page scan !!\n");
3519                 btc8723b2ant_action_bt_inquiry(btcoexist);
3520                 return;
3521         }
3522
3523         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3524         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3525         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3526
3527         if (scan || link || roam) {
3528                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3529                          "[BTCoex], WiFi is under Link Process !!\n");
3530                 btc8723b2ant_action_wifi_link_process(btcoexist);
3531                 return;
3532         }
3533
3534         /* for P2P */
3535         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3536                            &wifi_link_status);
3537         num_of_wifi_link = wifi_link_status >> 16;
3538
3539         if ((num_of_wifi_link >= 2) ||
3540             (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3541                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3542                          "############# [BTCoex],  Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3543                          num_of_wifi_link, wifi_link_status);
3544
3545                 if (bt_link_info->bt_link_exist)
3546                         miracast_plus_bt = true;
3547                 else
3548                         miracast_plus_bt = false;
3549
3550                 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3551                                    &miracast_plus_bt);
3552                 btc8723b2ant_action_wifi_multi_port(btcoexist);
3553
3554                 return;
3555         }
3556
3557         miracast_plus_bt = false;
3558         btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3559                            &miracast_plus_bt);
3560
3561         coex_dm->cur_algorithm = algorithm;
3562         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3563                  "[BTCoex], Algorithm = %d\n",
3564                  coex_dm->cur_algorithm);
3565
3566         if (btc8723b2ant_is_common_action(btcoexist)) {
3567                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3568                          "[BTCoex], Action 2-Ant common\n");
3569                 coex_dm->auto_tdma_adjust = false;
3570         } else {
3571                 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3572                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3573                                  "[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n",
3574                                  coex_dm->pre_algorithm,
3575                                  coex_dm->cur_algorithm);
3576                         coex_dm->auto_tdma_adjust = false;
3577                 }
3578                 switch (coex_dm->cur_algorithm) {
3579                 case BT_8723B_2ANT_COEX_ALGO_SCO:
3580                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3581                                  "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3582                         btc8723b2ant_action_sco(btcoexist);
3583                         break;
3584                 case BT_8723B_2ANT_COEX_ALGO_HID:
3585                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3586                                  "[BTCoex], Action 2-Ant, algorithm = HID\n");
3587                         btc8723b2ant_action_hid(btcoexist);
3588                         break;
3589                 case BT_8723B_2ANT_COEX_ALGO_A2DP:
3590                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3591                                  "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3592                         btc8723b2ant_action_a2dp(btcoexist);
3593                         break;
3594                 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
3595                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3596                                  "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3597                         btc8723b2ant_action_a2dp_pan_hs(btcoexist);
3598                         break;
3599                 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
3600                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3601                                  "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3602                         btc8723b2ant_action_pan_edr(btcoexist);
3603                         break;
3604                 case BT_8723B_2ANT_COEX_ALGO_PANHS:
3605                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3606                                  "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3607                         btc8723b2ant_action_pan_hs(btcoexist);
3608                         break;
3609                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
3610                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3611                                  "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3612                         btc8723b2ant_action_pan_edr_a2dp(btcoexist);
3613                         break;
3614                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
3615                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3616                                  "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3617                         btc8723b2ant_action_pan_edr_hid(btcoexist);
3618                         break;
3619                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3620                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3621                                  "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3622                         btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
3623                         break;
3624                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
3625                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3626                                  "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3627                         btc8723b2ant_action_hid_a2dp(btcoexist);
3628                         break;
3629                 default:
3630                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3631                                  "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3632                         btc8723b2ant_coex_alloff(btcoexist);
3633                         break;
3634                 }
3635                 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3636         }
3637 }
3638
3639 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist)
3640 {
3641         bool is_in_mp_mode = false;
3642         u8 h2c_parameter[2] = {0};
3643         u32 fw_ver = 0;
3644
3645         /* set wlan_act to low */
3646         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3647
3648         /* WiFi standby while GNT_BT 0 -> 1 */
3649         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
3650
3651         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3652         if (fw_ver >= 0x180000) {
3653                 /* Use H2C to set GNT_BT to HIGH */
3654                 h2c_parameter[0] = 1;
3655                 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
3656         } else {
3657                 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
3658         }
3659
3660         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
3661                            &is_in_mp_mode);
3662         if (!is_in_mp_mode)
3663                 /* BT select s0/s1 is controlled by BT */
3664                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
3665         else
3666                 /* BT select s0/s1 is controlled by WiFi */
3667                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
3668 }
3669
3670 /*********************************************************************
3671  *  extern function start with ex_btc8723b2ant_
3672  *********************************************************************/
3673 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
3674 {
3675         struct rtl_priv *rtlpriv = btcoexist->adapter;
3676         u8 u8tmp = 0;
3677
3678         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3679                  "[BTCoex], 2Ant Init HW Config!!\n");
3680         coex_dm->bt_rf0x1e_backup =
3681                 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3682
3683         /* 0x790[5:0] = 0x5 */
3684         u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3685         u8tmp &= 0xc0;
3686         u8tmp |= 0x5;
3687         btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3688
3689         /* Antenna config */
3690         btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
3691                                   true, false);
3692         coex_sta->dis_ver_info_cnt = 0;
3693
3694         /* PTA parameter */
3695         btc8723b2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3696
3697         /* Enable counter statistics */
3698         /* 0x76e[3] = 1, WLAN_ACT controlled by PTA */
3699         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3700         btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3701         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3702         btcoexist->auto_report_2ant = true;
3703 }
3704
3705 void ex_btc8723b2ant_power_on_setting(struct btc_coexist *btcoexist)
3706 {
3707         struct btc_board_info *board_info = &btcoexist->board_info;
3708         u16 u16tmp = 0x0;
3709         u32 value = 0;
3710
3711         btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
3712
3713         /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly */
3714         u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
3715         btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT0 | BIT1);
3716
3717         btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
3718
3719         if (btcoexist->chip_interface == BTC_INTF_USB) {
3720                 /* fixed at S0 for USB interface */
3721                 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
3722         } else {
3723                 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3724                 if (board_info->single_ant_path == 0) {
3725                         /* set to S1 */
3726                         board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3727                 } else if (board_info->single_ant_path == 1) {
3728                         /* set to S0 */
3729                         board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
3730                 }
3731                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
3732                                    &value);
3733         }
3734 }
3735
3736 void ex_btc8723b2ant_pre_load_firmware(struct btc_coexist *btcoexist)
3737 {
3738         struct btc_board_info *board_info = &btcoexist->board_info;
3739         u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
3740
3741         /**
3742          * S0 or S1 setting and Local register setting(By this fw can get
3743          * ant number, S0/S1, ... info)
3744          *
3745          * Local setting bit define
3746          *      BIT0: "0" : no antenna inverse; "1" : antenna inverse
3747          *      BIT1: "0" : internal switch; "1" : external switch
3748          *      BIT2: "0" : one antenna; "1" : two antennas
3749          *
3750          * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
3751          * BIT2 = 0
3752          */
3753         if (btcoexist->chip_interface == BTC_INTF_USB) {
3754                 /* fixed at S0 for USB interface */
3755                 u8tmp |= 0x1; /* antenna inverse */
3756                 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3757         } else {
3758                 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3759                 if (board_info->single_ant_path == 0) {
3760                 } else if (board_info->single_ant_path == 1) {
3761                         /* set to S0 */
3762                         u8tmp |= 0x1; /* antenna inverse */
3763                 }
3764
3765                 if (btcoexist->chip_interface == BTC_INTF_PCI)
3766                         btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
3767                                                              u8tmp);
3768                 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3769                         btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
3770                                                              u8tmp);
3771         }
3772 }
3773
3774 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3775 {
3776         struct rtl_priv *rtlpriv = btcoexist->adapter;
3777
3778         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3779                  "[BTCoex], Coex Mechanism Init!!\n");
3780         btc8723b2ant_init_coex_dm(btcoexist);
3781 }
3782
3783 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
3784 {
3785         struct btc_board_info *board_info = &btcoexist->board_info;
3786         struct btc_stack_info *stack_info = &btcoexist->stack_info;
3787         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3788         struct rtl_priv *rtlpriv = btcoexist->adapter;
3789         u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3790         u32 u32tmp[4];
3791         bool roam = false, scan = false;
3792         bool link = false, wifi_under_5g = false;
3793         bool bt_hs_on = false, wifi_busy = false;
3794         s32 wifi_rssi = 0, bt_hs_rssi = 0;
3795         u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3796         u8 wifi_dot11_chnl, wifi_hs_chnl;
3797         u32 fw_ver = 0, bt_patch_ver = 0;
3798         u8 ap_num = 0;
3799
3800         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3801                  "\r\n ============[BT Coexist info]============");
3802
3803         if (btcoexist->manual_control) {
3804                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3805                          "\r\n ==========[Under Manual Control]============");
3806                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3807                          "\r\n ==========================================");
3808         }
3809
3810         if (!board_info->bt_exist) {
3811                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3812                 return;
3813         }
3814
3815         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3816                  "Ant PG number/ Ant mechanism:",
3817                  board_info->pg_ant_num, board_info->btdm_ant_num);
3818
3819         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
3820                  "BT stack/ hci ext ver",
3821                  ((stack_info->profile_notified) ? "Yes" : "No"),
3822                  stack_info->hci_version);
3823
3824         btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3825         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3826         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3827                  "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3828                  "CoexVer/ FwVer/ PatchVer",
3829                  glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3830                  fw_ver, bt_patch_ver, bt_patch_ver);
3831
3832         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3833         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3834                            &wifi_dot11_chnl);
3835         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3836
3837         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
3838                  "Dot11 channel / HsChnl(HsMode)",
3839                  wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3840
3841         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %3ph ",
3842                  "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info);
3843
3844         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3845         btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3846         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3847         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d",
3848                  "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num);
3849
3850         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3851         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3852         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3853         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3854                  "Wifi link/ roam/ scan", link, roam, scan);
3855
3856         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3857         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3858         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3859         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3860                            &wifi_traffic_dir);
3861         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
3862                  "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3863                  ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
3864                  (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))),
3865                  ((!wifi_busy) ? "idle" :
3866                  ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
3867                   "uplink" : "downlink")));
3868
3869         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d",
3870                  "SCO/HID/PAN/A2DP",
3871                  bt_link_info->sco_exist, bt_link_info->hid_exist,
3872                  bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3873         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3874
3875         bt_info_ext = coex_sta->bt_info_ext;
3876         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3877                  "BT Info A2DP rate",
3878                  (bt_info_ext & BIT0) ? "Basic rate" : "EDR rate");
3879
3880         for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3881                 if (coex_sta->bt_info_c2h_cnt[i]) {
3882                         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3883                                  "\r\n %-35s = %7ph(%d)",
3884                                  glbt_info_src_8723b_2ant[i],
3885                                  coex_sta->bt_info_c2h[i],
3886                                  coex_sta->bt_info_c2h_cnt[i]);
3887                 }
3888         }
3889
3890         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3891                  "PS state, IPS/LPS",
3892                  ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3893                  ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3894         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3895
3896         /* Sw mechanism */
3897         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3898                  "\r\n %-35s", "============[Sw mechanism]============");
3899         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3900                  "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3901                  coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3902         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3903                  "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3904                  coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3905                  coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3906
3907         /* Fw mechanism */
3908         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3909                  "============[Fw mechanism]============");
3910
3911         ps_tdma_case = coex_dm->cur_ps_tdma;
3912         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3913                  "\r\n %-35s = %5ph case-%d (auto:%d)",
3914                  "PS TDMA", coex_dm->ps_tdma_para,
3915                  ps_tdma_case, coex_dm->auto_tdma_adjust);
3916
3917         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3918                  "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr_lvl,
3919                  coex_dm->cur_ignore_wlan_act);
3920
3921         /* Hw setting */
3922         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3923                  "============[Hw setting]============");
3924
3925         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3926                  "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3927
3928         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3929         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3930         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3931                  "0x778/0x880[29:25]", u8tmp[0],
3932                  (u32tmp[0] & 0x3e000000) >> 25);
3933
3934         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3935         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3936         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3937         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3938                  "0x948/ 0x67[5] / 0x765",
3939                  u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]);
3940
3941         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3942         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3943         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3944         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3945                  "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3946                  u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
3947
3948         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3949         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3950         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3951         u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3952         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3953                  "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3954                  "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3955                  ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
3956                  ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
3957
3958         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3959         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3960         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3961                  "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3962
3963         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3964         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3965         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3966                  "0xc50(dig)/0x49c(null-drop)", u32tmp[0] & 0xff, u8tmp[0]);
3967
3968         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3969         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3970         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3971         u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3972
3973         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3974         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3975
3976         fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3977                   ((u32tmp[1]&0xffff0000) >> 16) +
3978                    (u32tmp[1] & 0xffff) +
3979                    (u32tmp[2] & 0xffff) +
3980                   ((u32tmp[3]&0xffff0000) >> 16) +
3981                    (u32tmp[3] & 0xffff);
3982         fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3983
3984         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3985                  "OFDM-CCA/OFDM-FA/CCK-FA",
3986                  u32tmp[0] & 0xffff, fa_ofdm, fa_cck);
3987
3988         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3989         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3990         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3991         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3992         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3993                  "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3994                  "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3995                  u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3996
3997         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3998                  "0x770(high-pri rx/tx)",
3999                  coex_sta->high_priority_rx, coex_sta->high_priority_tx);
4000         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
4001                  "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
4002                  coex_sta->low_priority_tx);
4003         if (btcoexist->auto_report_2ant)
4004                 btc8723b2ant_monitor_bt_ctr(btcoexist);
4005         btcoexist->btc_disp_dbg_msg(btcoexist,
4006         BTC_DBG_DISP_COEX_STATISTICS);
4007 }
4008
4009 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
4010 {
4011         struct rtl_priv *rtlpriv = btcoexist->adapter;
4012
4013         if (BTC_IPS_ENTER == type) {
4014                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4015                          "[BTCoex], IPS ENTER notify\n");
4016                 coex_sta->under_ips = true;
4017                 btc8723b2ant_wifioff_hwcfg(btcoexist);
4018                 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4019                 btc8723b2ant_coex_alloff(btcoexist);
4020         } else if (BTC_IPS_LEAVE == type) {
4021                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4022                          "[BTCoex], IPS LEAVE notify\n");
4023                 coex_sta->under_ips = false;
4024                 ex_btc8723b2ant_init_hwconfig(btcoexist);
4025                 btc8723b2ant_init_coex_dm(btcoexist);
4026                 btc8723b2ant_query_bt_info(btcoexist);
4027         }
4028 }
4029
4030 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
4031 {
4032         struct rtl_priv *rtlpriv = btcoexist->adapter;
4033
4034         if (BTC_LPS_ENABLE == type) {
4035                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4036                          "[BTCoex], LPS ENABLE notify\n");
4037                 coex_sta->under_lps = true;
4038         } else if (BTC_LPS_DISABLE == type) {
4039                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4040                          "[BTCoex], LPS DISABLE notify\n");
4041                 coex_sta->under_lps = false;
4042         }
4043 }
4044
4045 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
4046 {
4047         struct rtl_priv *rtlpriv = btcoexist->adapter;
4048         u32 u32tmp;
4049         u8 u8tmpa, u8tmpb;
4050
4051         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
4052         u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
4053         u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
4054
4055         if (BTC_SCAN_START == type)
4056                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4057                          "[BTCoex], SCAN START notify\n");
4058         else if (BTC_SCAN_FINISH == type)
4059                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4060                          "[BTCoex], SCAN FINISH notify\n");
4061         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4062                            &coex_sta->scan_ap_num);
4063
4064         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4065                  "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x76e=0x%x\n",
4066                 u32tmp, u8tmpa, u8tmpb);
4067 }
4068
4069 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
4070 {
4071         struct rtl_priv *rtlpriv = btcoexist->adapter;
4072
4073         if (BTC_ASSOCIATE_START == type)
4074                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4075                          "[BTCoex], CONNECT START notify\n");
4076         else if (BTC_ASSOCIATE_FINISH == type)
4077                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4078                          "[BTCoex], CONNECT FINISH notify\n");
4079 }
4080
4081 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
4082                                          u8 type)
4083 {
4084         struct rtl_priv *rtlpriv = btcoexist->adapter;
4085         u8 h2c_parameter[3] = {0};
4086         u32 wifi_bw;
4087         u8 wifi_central_chnl;
4088         u8 ap_num = 0;
4089
4090         if (BTC_MEDIA_CONNECT == type)
4091                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4092                          "[BTCoex], MEDIA connect notify\n");
4093         else
4094                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4095                          "[BTCoex], MEDIA disconnect notify\n");
4096
4097         /* only 2.4G we need to inform bt the chnl mask */
4098         btcoexist->btc_get(btcoexist,
4099                 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
4100         if ((BTC_MEDIA_CONNECT == type) &&
4101             (wifi_central_chnl <= 14)) {
4102                 h2c_parameter[0] = 0x1;
4103                 h2c_parameter[1] = wifi_central_chnl;
4104                 btcoexist->btc_get(btcoexist,
4105                         BTC_GET_U4_WIFI_BW, &wifi_bw);
4106                 if (wifi_bw == BTC_WIFI_BW_HT40) {
4107                         h2c_parameter[2] = 0x30;
4108                 } else {
4109                         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4110                                            &ap_num);
4111                         if (ap_num < 10)
4112                                 h2c_parameter[2] = 0x30;
4113                         else
4114                                 h2c_parameter[2] = 0x20;
4115                 }
4116         }
4117
4118         coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
4119         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
4120         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
4121
4122         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4123                  "[BTCoex], FW write 0x66=0x%x\n",
4124                  h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
4125                  h2c_parameter[2]);
4126
4127         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
4128 }
4129
4130 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
4131                                            u8 type)
4132 {
4133         struct rtl_priv *rtlpriv = btcoexist->adapter;
4134
4135         if (type == BTC_PACKET_DHCP)
4136                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4137                          "[BTCoex], DHCP Packet notify\n");
4138 }
4139
4140 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
4141                                     u8 *tmpbuf, u8 length)
4142 {
4143         struct rtl_priv *rtlpriv = btcoexist->adapter;
4144         u8 bt_info = 0;
4145         u8 i, rsp_source = 0;
4146         bool bt_busy = false, limited_dig = false;
4147         bool wifi_connected = false;
4148
4149         coex_sta->c2h_bt_info_req_sent = false;
4150
4151         rsp_source = tmpbuf[0]&0xf;
4152         if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
4153                 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
4154         coex_sta->bt_info_c2h_cnt[rsp_source]++;
4155
4156         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4157                  "[BTCoex], Bt info[%d], length=%d, hex data=[",
4158                  rsp_source, length);
4159         for (i = 0; i < length; i++) {
4160                 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
4161                 if (i == 1)
4162                         bt_info = tmpbuf[i];
4163                 if (i == length - 1)
4164                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4165                                  "0x%02x]\n", tmpbuf[i]);
4166                 else
4167                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4168                                  "0x%02x, ", tmpbuf[i]);
4169         }
4170
4171         if (btcoexist->manual_control) {
4172                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4173                          "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
4174                 return;
4175         }
4176
4177         if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
4178                 coex_sta->bt_retry_cnt =
4179                         coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
4180
4181                 if (coex_sta->bt_retry_cnt >= 1)
4182                         coex_sta->pop_event_cnt++;
4183
4184                 coex_sta->bt_rssi =
4185                         coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4186
4187                 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4188
4189                 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
4190                         coex_sta->c2h_bt_remote_name_req = true;
4191                 else
4192                         coex_sta->c2h_bt_remote_name_req = false;
4193
4194                 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49)
4195                         coex_sta->a2dp_bit_pool =
4196                                 coex_sta->bt_info_c2h[rsp_source][6];
4197                 else
4198                         coex_sta->a2dp_bit_pool = 0;
4199
4200                 /* Here we need to resend some wifi info to BT
4201                  * because BT is reset and loss of the info.
4202                  */
4203                 if ((coex_sta->bt_info_ext & BIT1)) {
4204                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4205                                  "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
4206                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4207                                            &wifi_connected);
4208                         if (wifi_connected)
4209                                 ex_btc8723b2ant_media_status_notify(
4210                                                         btcoexist,
4211                                                         BTC_MEDIA_CONNECT);
4212                         else
4213                                 ex_btc8723b2ant_media_status_notify(
4214                                                         btcoexist,
4215                                                         BTC_MEDIA_DISCONNECT);
4216                 }
4217
4218                 if ((coex_sta->bt_info_ext & BIT3)) {
4219                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4220                                  "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4221                         btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
4222                                                      false);
4223                 } else {
4224                         /* BT already NOT ignore Wlan active, do nothing here.*/
4225                 }
4226                 if (!btcoexist->auto_report_2ant) {
4227                         if (!(coex_sta->bt_info_ext & BIT4))
4228                                 btc8723b2ant_bt_auto_report(btcoexist,
4229                                                             FORCE_EXEC, true);
4230                 }
4231         }
4232
4233         /* check BIT2 first ==> check if bt is under inquiry or page scan */
4234         if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
4235                 coex_sta->c2h_bt_inquiry_page = true;
4236         else
4237                 coex_sta->c2h_bt_inquiry_page = false;
4238
4239         if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4240                 /* set link exist status */
4241                 coex_sta->bt_link_exist = false;
4242                 coex_sta->pan_exist = false;
4243                 coex_sta->a2dp_exist = false;
4244                 coex_sta->hid_exist = false;
4245                 coex_sta->sco_exist = false;
4246         } else {
4247                 /* connection exists */
4248                 coex_sta->bt_link_exist = true;
4249                 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
4250                         coex_sta->pan_exist = true;
4251                 else
4252                         coex_sta->pan_exist = false;
4253                 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
4254                         coex_sta->a2dp_exist = true;
4255                 else
4256                         coex_sta->a2dp_exist = false;
4257                 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
4258                         coex_sta->hid_exist = true;
4259                 else
4260                         coex_sta->hid_exist = false;
4261                 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
4262                         coex_sta->sco_exist = true;
4263                 else
4264                         coex_sta->sco_exist = false;
4265
4266                 if ((!coex_sta->hid_exist) &&
4267                     (!coex_sta->c2h_bt_inquiry_page) &&
4268                     (!coex_sta->sco_exist)) {
4269                         if (coex_sta->high_priority_tx +
4270                                     coex_sta->high_priority_rx >= 160) {
4271                                 coex_sta->hid_exist = true;
4272                                 bt_info = bt_info | 0x28;
4273                         }
4274                 }
4275         }
4276
4277         btc8723b2ant_update_bt_link_info(btcoexist);
4278
4279         if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4280                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
4281                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4282                          "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4283         /* connection exists but no busy */
4284         } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
4285                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
4286                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4287                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4288         } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
4289                    (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
4290                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
4291                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4292                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4293         } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
4294                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
4295                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4296                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4297         } else {
4298                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
4299                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4300                          "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4301         }
4302
4303         if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
4304             (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
4305             (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
4306                 bt_busy = true;
4307                 limited_dig = true;
4308         } else {
4309                 bt_busy = false;
4310                 limited_dig = false;
4311         }
4312
4313         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4314
4315         coex_dm->limited_dig = limited_dig;
4316         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4317
4318         btc8723b2ant_run_coexist_mechanism(btcoexist);
4319 }
4320
4321 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
4322 {
4323         struct rtl_priv *rtlpriv = btcoexist->adapter;
4324
4325         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n");
4326
4327         btc8723b2ant_wifioff_hwcfg(btcoexist);
4328         btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4329         ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4330 }
4331
4332 void ex_btc8723b2ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
4333 {
4334         struct rtl_priv *rtlpriv = btcoexist->adapter;
4335
4336         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
4337
4338         if (pnp_state == BTC_WIFI_PNP_SLEEP) {
4339                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4340                          "[BTCoex], Pnp notify to SLEEP\n");
4341
4342                 /* Driver do not leave IPS/LPS when driver is going to sleep, so
4343                  * BTCoexistence think wifi is still under IPS/LPS
4344                  *
4345                  * BT should clear UnderIPS/UnderLPS state to avoid mismatch
4346                  * state after wakeup.
4347                  */
4348                 coex_sta->under_ips = false;
4349                 coex_sta->under_lps = false;
4350         } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
4351                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4352                          "[BTCoex], Pnp notify to WAKE UP\n");
4353                 ex_btc8723b2ant_init_hwconfig(btcoexist);
4354                 btc8723b2ant_init_coex_dm(btcoexist);
4355                 btc8723b2ant_query_bt_info(btcoexist);
4356         }
4357 }
4358
4359 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
4360 {
4361         struct rtl_priv *rtlpriv = btcoexist->adapter;
4362         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
4363
4364         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4365                  "[BTCoex], ==========================Periodical===========================\n");
4366
4367         if (coex_sta->dis_ver_info_cnt <= 5) {
4368                 coex_sta->dis_ver_info_cnt += 1;
4369                 if (coex_sta->dis_ver_info_cnt == 3) {
4370                         /* Antenna config to set 0x765 = 0x0 (GNT_BT control by
4371                          * PTA) after initial
4372                          */
4373                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4374                                  "[BTCoex], Set GNT_BT control by PTA\n");
4375                         btc8723b2ant_set_ant_path(
4376                                 btcoexist, BTC_ANT_WIFI_AT_MAIN, false, false);
4377                 }
4378         }
4379
4380         if (!btcoexist->auto_report_2ant) {
4381                 btc8723b2ant_query_bt_info(btcoexist);
4382         } else {
4383                 btc8723b2ant_monitor_bt_ctr(btcoexist);
4384                 btc8723b2ant_monitor_wifi_ctr(btcoexist);
4385
4386                 /* for some BT speakers that High-Priority pkts appear before
4387                  * playing, this will cause HID exist
4388                  */
4389                 if ((coex_sta->high_priority_tx +
4390                     coex_sta->high_priority_rx < 50) &&
4391                     (bt_link_info->hid_exist))
4392                         bt_link_info->hid_exist = false;
4393
4394                 if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
4395                     coex_dm->auto_tdma_adjust)
4396                         btc8723b2ant_run_coexist_mechanism(btcoexist);
4397         }
4398 }