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(u8 level_num, u8 rssi_thresh,
  62                                      u8 rssi_thresh1)
  63 {
  64         s32 bt_rssi = 0;
  65         u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
  66
  67         bt_rssi = coex_sta->bt_rssi;
  68
  69         if (level_num == 2) {
  70                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  71                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  72                         if (bt_rssi >= rssi_thresh +
  73                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
  74                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
  75                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  76                                             "[BTCoex], BT Rssi state switch to High\n");
  77                         } else {
  78                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  79                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  80                                             "[BTCoex], BT Rssi state stay at Low\n");
  81                         }
  82                 } else {
  83                         if (bt_rssi < rssi_thresh) {
  84                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
  85                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  86                                             "[BTCoex], BT Rssi state switch to Low\n");
  87                         } else {
  88                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
  89                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  90                                             "[BTCoex], BT Rssi state stay at High\n");
  91                         }
  92                 }
  93         } else if (level_num == 3) {
  94                 if (rssi_thresh > rssi_thresh1) {
  95                         btc_alg_dbg(ALGO_BT_RSSI_STATE,
  96                                     "[BTCoex], BT Rssi thresh error!!\n");
  97                         return coex_sta->pre_bt_rssi_state;
  98                 }
  99
 100                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
 101                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 102                         if (bt_rssi >= rssi_thresh +
 103                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 104                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 105                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 106                                             "[BTCoex], BT Rssi state switch to Medium\n");
 107                         } else {
 108                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 109                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 110                                             "[BTCoex], BT Rssi state stay at Low\n");
 111                         }
 112                 } else if ((coex_sta->pre_bt_rssi_state ==
 113                                                 BTC_RSSI_STATE_MEDIUM) ||
 114                            (coex_sta->pre_bt_rssi_state ==
 115                                                 BTC_RSSI_STATE_STAY_MEDIUM)) {
 116                         if (bt_rssi >= rssi_thresh1 +
 117                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 118                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
 119                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 120                                             "[BTCoex], BT Rssi state switch to High\n");
 121                         } else if (bt_rssi < rssi_thresh) {
 122                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
 123                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 124                                             "[BTCoex], BT Rssi state switch to Low\n");
 125                         } else {
 126                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 127                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 128                                             "[BTCoex], BT Rssi state stay at Medium\n");
 129                         }
 130                 } else {
 131                         if (bt_rssi < rssi_thresh1) {
 132                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 133                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 134                                             "[BTCoex], BT Rssi state switch to Medium\n");
 135                         } else {
 136                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 137                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 138                                             "[BTCoex], BT Rssi state stay at High\n");
 139                         }
 140                 }
 141         }
 142
 143         coex_sta->pre_bt_rssi_state = bt_rssi_state;
 144
 145         return bt_rssi_state;
 146 }
 147
 148 static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
 149                                        u8 index, u8 level_num,
 150                                        u8 rssi_thresh, u8 rssi_thresh1)
 151 {
 152         s32 wifi_rssi = 0;
 153         u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
 154
 155         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 156
 157         if (level_num == 2) {
 158                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 159                                                 BTC_RSSI_STATE_LOW) ||
 160                     (coex_sta->pre_wifi_rssi_state[index] ==
 161                                                 BTC_RSSI_STATE_STAY_LOW)) {
 162                         if (wifi_rssi >= rssi_thresh +
 163                                          BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 164                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 165                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 166                                             "[BTCoex], wifi RSSI state switch to High\n");
 167                         } else {
 168                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 169                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 170                                             "[BTCoex], wifi RSSI state stay at Low\n");
 171                         }
 172                 } else {
 173                         if (wifi_rssi < rssi_thresh) {
 174                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 175                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 176                                             "[BTCoex], wifi RSSI state switch to Low\n");
 177                         } else {
 178                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 179                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 180                                             "[BTCoex], wifi RSSI state stay at High\n");
 181                         }
 182                 }
 183         } else if (level_num == 3) {
 184                 if (rssi_thresh > rssi_thresh1) {
 185                         btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 186                                     "[BTCoex], wifi RSSI thresh error!!\n");
 187                         return coex_sta->pre_wifi_rssi_state[index];
 188                 }
 189
 190                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 191                                                 BTC_RSSI_STATE_LOW) ||
 192                     (coex_sta->pre_wifi_rssi_state[index] ==
 193                                                 BTC_RSSI_STATE_STAY_LOW)) {
 194                         if (wifi_rssi >= rssi_thresh +
 195                                         BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 196                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 197                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 198                                             "[BTCoex], wifi RSSI state switch to Medium\n");
 199                         } else {
 200                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 201                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 202                                             "[BTCoex], wifi RSSI state stay at Low\n");
 203                         }
 204                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
 205                                                 BTC_RSSI_STATE_MEDIUM) ||
 206                            (coex_sta->pre_wifi_rssi_state[index] ==
 207                                                 BTC_RSSI_STATE_STAY_MEDIUM)) {
 208                         if (wifi_rssi >= rssi_thresh1 +
 209                                          BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 210                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 211                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 212                                             "[BTCoex], wifi RSSI state switch to High\n");
 213                         } else if (wifi_rssi < rssi_thresh) {
 214                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 215                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 216                                             "[BTCoex], wifi RSSI state switch to Low\n");
 217                         } else {
 218                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 219                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 220                                             "[BTCoex], wifi RSSI state stay at Medium\n");
 221                         }
 222                 } else {
 223                         if (wifi_rssi < rssi_thresh1) {
 224                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 225                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 226                                             "[BTCoex], wifi RSSI state switch to Medium\n");
 227                         } else {
 228                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 229                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 230                                             "[BTCoex], wifi RSSI state stay at High\n");
 231                         }
 232                 }
 233         }
 234
 235         coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
 236
 237         return wifi_rssi_state;
 238 }
 239
 240 static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
 241 {
 242         u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
 243         u32 reg_hp_tx = 0, reg_hp_rx = 0;
 244         u32 reg_lp_tx = 0, reg_lp_rx = 0;
 245
 246         reg_hp_txrx = 0x770;
 247         reg_lp_txrx = 0x774;
 248
 249         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
 250         reg_hp_tx = u32tmp & MASKLWORD;
 251         reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
 252
 253         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
 254         reg_lp_tx = u32tmp & MASKLWORD;
 255         reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
 256
 257         coex_sta->high_priority_tx = reg_hp_tx;
 258         coex_sta->high_priority_rx = reg_hp_rx;
 259         coex_sta->low_priority_tx = reg_lp_tx;
 260         coex_sta->low_priority_rx = reg_lp_rx;
 261
 262         btc_alg_dbg(ALGO_BT_MONITOR,
 263                     "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
 264                     reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
 265         btc_alg_dbg(ALGO_BT_MONITOR,
 266                     "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
 267                     reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 268
 269         /* reset counter */
 270         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 271 }
 272
 273 static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist)
 274 {
 275         u8 h2c_parameter[1] = {0};
 276
 277         coex_sta->c2h_bt_info_req_sent = true;
 278
 279         h2c_parameter[0] |= BIT0;       /* trigger */
 280
 281         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 282                     "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
 283                     h2c_parameter[0]);
 284
 285         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 286 }
 287
 288 static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
 289 {
 290         static bool pre_wifi_busy;
 291         static bool pre_under_4way;
 292         static bool pre_bt_hs_on;
 293         bool wifi_busy = false, under_4way = false, bt_hs_on = false;
 294         bool wifi_connected = false;
 295
 296         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 297                            &wifi_connected);
 298         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 299         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 300         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
 301                            &under_4way);
 302
 303         if (wifi_connected) {
 304                 if (wifi_busy != pre_wifi_busy) {
 305                         pre_wifi_busy = wifi_busy;
 306                         return true;
 307                 }
 308
 309                 if (under_4way != pre_under_4way) {
 310                         pre_under_4way = under_4way;
 311                         return true;
 312                 }
 313
 314                 if (bt_hs_on != pre_bt_hs_on) {
 315                         pre_bt_hs_on = bt_hs_on;
 316                         return true;
 317                 }
 318         }
 319
 320         return false;
 321 }
 322
 323 static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist)
 324 {
 325         /*struct btc_stack_info *stack_info = &btcoexist->stack_info;*/
 326         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 327         bool bt_hs_on = false;
 328
 329 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1) /* profile from bt patch */
 330         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 331
 332         bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
 333         bt_link_info->sco_exist = coex_sta->sco_exist;
 334         bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
 335         bt_link_info->pan_exist = coex_sta->pan_exist;
 336         bt_link_info->hid_exist = coex_sta->hid_exist;
 337
 338         /* work around for HS mode. */
 339         if (bt_hs_on) {
 340                 bt_link_info->pan_exist = true;
 341                 bt_link_info->bt_link_exist = true;
 342         }
 343 #else   /* profile from bt stack */
 344         bt_link_info->bt_link_exist = stack_info->bt_link_exist;
 345         bt_link_info->sco_exist = stack_info->sco_exist;
 346         bt_link_info->a2dp_exist = stack_info->a2dp_exist;
 347         bt_link_info->pan_exist = stack_info->pan_exist;
 348         bt_link_info->hid_exist = stack_info->hid_exist;
 349
 350         /*for win-8 stack HID report error*/
 351         if (!stack_info->hid_exist)
 352                 stack_info->hid_exist = coex_sta->hid_exist;
 353         /*sync  BTInfo with BT firmware and stack*/
 354         /* when stack HID report error, here we use the info from bt fw.*/
 355         if (!stack_info->bt_link_exist)
 356                 stack_info->bt_link_exist = coex_sta->bt_link_exist;
 357 #endif
 358         /* check if Sco only */
 359         if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 360             !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 361                 bt_link_info->sco_only = true;
 362         else
 363                 bt_link_info->sco_only = false;
 364
 365         /* check if A2dp only */
 366         if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
 367             !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 368                 bt_link_info->a2dp_only = true;
 369         else
 370                 bt_link_info->a2dp_only = false;
 371
 372         /* check if Pan only */
 373         if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 374             bt_link_info->pan_exist && !bt_link_info->hid_exist)
 375                 bt_link_info->pan_only = true;
 376         else
 377                 bt_link_info->pan_only = false;
 378
 379         /* check if Hid only */
 380         if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 381             !bt_link_info->pan_exist && bt_link_info->hid_exist)
 382                 bt_link_info->hid_only = true;
 383         else
 384                 bt_link_info->hid_only = false;
 385 }
 386
 387 static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
 388 {
 389         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 390         bool bt_hs_on = false;
 391         u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
 392         u8 num_of_diff_profile = 0;
 393
 394         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 395
 396         if (!bt_link_info->bt_link_exist) {
 397                 btc_alg_dbg(ALGO_TRACE,
 398                             "[BTCoex], No BT link exists!!!\n");
 399                 return algorithm;
 400         }
 401
 402         if (bt_link_info->sco_exist)
 403                 num_of_diff_profile++;
 404         if (bt_link_info->hid_exist)
 405                 num_of_diff_profile++;
 406         if (bt_link_info->pan_exist)
 407                 num_of_diff_profile++;
 408         if (bt_link_info->a2dp_exist)
 409                 num_of_diff_profile++;
 410
 411         if (num_of_diff_profile == 1) {
 412                 if (bt_link_info->sco_exist) {
 413                         btc_alg_dbg(ALGO_TRACE,
 414                                     "[BTCoex], SCO only\n");
 415                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 416                 } else {
 417                         if (bt_link_info->hid_exist) {
 418                                 btc_alg_dbg(ALGO_TRACE,
 419                                             "[BTCoex], HID only\n");
 420                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 421                         } else if (bt_link_info->a2dp_exist) {
 422                                 btc_alg_dbg(ALGO_TRACE,
 423                                             "[BTCoex], A2DP only\n");
 424                                 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
 425                         } else if (bt_link_info->pan_exist) {
 426                                 if (bt_hs_on) {
 427                                         btc_alg_dbg(ALGO_TRACE,
 428                                                     "[BTCoex], PAN(HS) only\n");
 429                                         algorithm =
 430                                                 BT_8723B_2ANT_COEX_ALGO_PANHS;
 431                                 } else {
 432                                         btc_alg_dbg(ALGO_TRACE,
 433                                                     "[BTCoex], PAN(EDR) only\n");
 434                                         algorithm =
 435                                                 BT_8723B_2ANT_COEX_ALGO_PANEDR;
 436                                 }
 437                         }
 438                 }
 439         } else if (num_of_diff_profile == 2) {
 440                 if (bt_link_info->sco_exist) {
 441                         if (bt_link_info->hid_exist) {
 442                                 btc_alg_dbg(ALGO_TRACE,
 443                                             "[BTCoex], SCO + HID\n");
 444                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 445                         } else if (bt_link_info->a2dp_exist) {
 446                                 btc_alg_dbg(ALGO_TRACE,
 447                                             "[BTCoex], SCO + A2DP ==> SCO\n");
 448                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 449                         } else if (bt_link_info->pan_exist) {
 450                                 if (bt_hs_on) {
 451                                         btc_alg_dbg(ALGO_TRACE,
 452                                                     "[BTCoex], SCO + PAN(HS)\n");
 453                                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 454                                 } else {
 455                                         btc_alg_dbg(ALGO_TRACE,
 456                                                     "[BTCoex], SCO + PAN(EDR)\n");
 457                                         algorithm =
 458                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 459                                 }
 460                         }
 461                 } else {
 462                         if (bt_link_info->hid_exist &&
 463                             bt_link_info->a2dp_exist) {
 464                                 btc_alg_dbg(ALGO_TRACE,
 465                                             "[BTCoex], HID + A2DP\n");
 466                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 467                         } else if (bt_link_info->hid_exist &&
 468                                    bt_link_info->pan_exist) {
 469                                 if (bt_hs_on) {
 470                                         btc_alg_dbg(ALGO_TRACE,
 471                                                     "[BTCoex], HID + PAN(HS)\n");
 472                                         algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 473                                 } else {
 474                                         btc_alg_dbg(ALGO_TRACE,
 475                                                     "[BTCoex], HID + PAN(EDR)\n");
 476                                         algorithm =
 477                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 478                                 }
 479                         } else if (bt_link_info->pan_exist &&
 480                                    bt_link_info->a2dp_exist) {
 481                                 if (bt_hs_on) {
 482                                         btc_alg_dbg(ALGO_TRACE,
 483                                                     "[BTCoex], A2DP + PAN(HS)\n");
 484                                         algorithm =
 485                                             BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
 486                                 } else {
 487                                         btc_alg_dbg(ALGO_TRACE,
 488                                                     "[BTCoex],A2DP + PAN(EDR)\n");
 489                                         algorithm =
 490                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
 491                                 }
 492                         }
 493                 }
 494         } else if (num_of_diff_profile == 3) {
 495                 if (bt_link_info->sco_exist) {
 496                         if (bt_link_info->hid_exist &&
 497                             bt_link_info->a2dp_exist) {
 498                                 btc_alg_dbg(ALGO_TRACE,
 499                                             "[BTCoex], SCO + HID + A2DP ==> HID\n");
 500                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 501                         } else if (bt_link_info->hid_exist &&
 502                                    bt_link_info->pan_exist) {
 503                                 if (bt_hs_on) {
 504                                         btc_alg_dbg(ALGO_TRACE,
 505                                                     "[BTCoex], SCO + HID + PAN(HS)\n");
 506                                         algorithm =
 507                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 508                                 } else {
 509                                         btc_alg_dbg(ALGO_TRACE,
 510                                                     "[BTCoex], SCO + HID + PAN(EDR)\n");
 511                                         algorithm =
 512                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 513                                 }
 514                         } else if (bt_link_info->pan_exist &&
 515                                    bt_link_info->a2dp_exist) {
 516                                 if (bt_hs_on) {
 517                                         btc_alg_dbg(ALGO_TRACE,
 518                                                     "[BTCoex], SCO + A2DP + PAN(HS)\n");
 519                                         algorithm =
 520                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 521                                 } else {
 522                                         btc_alg_dbg(ALGO_TRACE,
 523                                                     "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
 524                                         algorithm =
 525                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 526                                 }
 527                         }
 528                 } else {
 529                         if (bt_link_info->hid_exist &&
 530                             bt_link_info->pan_exist &&
 531                             bt_link_info->a2dp_exist) {
 532                                 if (bt_hs_on) {
 533                                         btc_alg_dbg(ALGO_TRACE,
 534                                                     "[BTCoex], HID + A2DP + PAN(HS)\n");
 535                                         algorithm =
 536                                             BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 537                                 } else {
 538                                         btc_alg_dbg(ALGO_TRACE,
 539                                                     "[BTCoex], HID + A2DP + PAN(EDR)\n");
 540                                         algorithm =
 541                                         BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
 542                                 }
 543                         }
 544                 }
 545         } else if (num_of_diff_profile >= 3) {
 546                 if (bt_link_info->sco_exist) {
 547                         if (bt_link_info->hid_exist &&
 548                             bt_link_info->pan_exist &&
 549                             bt_link_info->a2dp_exist) {
 550                                 if (bt_hs_on) {
 551                                         btc_alg_dbg(ALGO_TRACE,
 552                                                     "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
 553                                 } else {
 554                                         btc_alg_dbg(ALGO_TRACE,
 555                                                     "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
 556                                         algorithm =
 557                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 558                                 }
 559                         }
 560                 }
 561         }
 562         return algorithm;
 563 }
 564
 565 static bool btc8723b_need_dec_pwr(struct btc_coexist *btcoexist)
 566 {
 567         bool ret = false;
 568         bool bt_hs_on = false, wifi_connected = false;
 569         s32 bt_hs_rssi = 0;
 570         u8 bt_rssi_state;
 571
 572         if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on))
 573                 return false;
 574         if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 575                                 &wifi_connected))
 576                 return false;
 577         if (!btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi))
 578                 return false;
 579
 580         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
 581
 582         if (wifi_connected) {
 583                 if (bt_hs_on) {
 584                         if (bt_hs_rssi > 37) {
 585                                 btc_alg_dbg(ALGO_TRACE_FW,
 586                                             "[BTCoex], Need to decrease bt power for HS mode!!\n");
 587                                 ret = true;
 588                         }
 589                 } else {
 590                         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
 591                             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
 592                                 btc_alg_dbg(ALGO_TRACE_FW,
 593                                             "[BTCoex], Need to decrease bt power for Wifi is connected!!\n");
 594                                 ret = true;
 595                         }
 596                 }
 597         }
 598
 599         return ret;
 600 }
 601
 602 static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
 603                                                 u8 dac_swing_lvl)
 604 {
 605         u8 h2c_parameter[1] = {0};
 606
 607         /* There are several type of dacswing
 608          * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
 609          */
 610         h2c_parameter[0] = dac_swing_lvl;
 611
 612         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 613                     "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
 614         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 615                     "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
 616
 617         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 618 }
 619
 620 static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
 621                                            bool dec_bt_pwr)
 622 {
 623         u8 h2c_parameter[1] = {0};
 624
 625         h2c_parameter[0] = 0;
 626
 627         if (dec_bt_pwr)
 628                 h2c_parameter[0] |= BIT1;
 629
 630         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 631                     "[BTCoex], decrease Bt Power : %s, FW write 0x62=0x%x\n",
 632                     (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
 633
 634         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 635 }
 636
 637 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
 638                                     bool force_exec, bool dec_bt_pwr)
 639 {
 640         btc_alg_dbg(ALGO_TRACE_FW,
 641                     "[BTCoex], %s Dec BT power = %s\n",
 642                     force_exec ? "force to" : "", dec_bt_pwr ? "ON" : "OFF");
 643         coex_dm->cur_dec_bt_pwr = dec_bt_pwr;
 644
 645         if (!force_exec) {
 646                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 647                             "[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n",
 648                             coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
 649
 650                 if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr)
 651                         return;
 652         }
 653         btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr);
 654
 655         coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr;
 656 }
 657
 658 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
 659                                           bool force_exec, u8 fw_dac_swing_lvl)
 660 {
 661         btc_alg_dbg(ALGO_TRACE_FW,
 662                     "[BTCoex], %s set FW Dac Swing level = %d\n",
 663                     (force_exec ? "force to" : ""), fw_dac_swing_lvl);
 664         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 665
 666         if (!force_exec) {
 667                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 668                             "[BTCoex], preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
 669                             coex_dm->pre_fw_dac_swing_lvl,
 670                             coex_dm->cur_fw_dac_swing_lvl);
 671
 672                 if (coex_dm->pre_fw_dac_swing_lvl ==
 673                    coex_dm->cur_fw_dac_swing_lvl)
 674                         return;
 675         }
 676
 677         btc8723b2ant_set_fw_dac_swing_level(btcoexist,
 678                                             coex_dm->cur_fw_dac_swing_lvl);
 679         coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
 680 }
 681
 682 static void btc8723b2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 683                                                  bool rx_rf_shrink_on)
 684 {
 685         if (rx_rf_shrink_on) {
 686                 /* Shrink RF Rx LPF corner */
 687                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 688                             "[BTCoex], Shrink RF Rx LPF corner!!\n");
 689                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
 690                                           0xfffff, 0xffffc);
 691         } else {
 692                 /* Resume RF Rx LPF corner */
 693                 /* After initialized, we can use coex_dm->btRf0x1eBackup */
 694                 if (btcoexist->initilized) {
 695                         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 696                                     "[BTCoex], Resume RF Rx LPF corner!!\n");
 697                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
 698                                                   0xfffff,
 699                                                   coex_dm->bt_rf0x1e_backup);
 700                 }
 701         }
 702 }
 703
 704 static void btc8723b2ant_rf_shrink(struct btc_coexist *btcoexist,
 705                                    bool force_exec, bool rx_rf_shrink_on)
 706 {
 707         btc_alg_dbg(ALGO_TRACE_SW,
 708                     "[BTCoex], %s turn Rx RF Shrink = %s\n",
 709                     (force_exec ? "force to" : ""), (rx_rf_shrink_on ?
 710                                                      "ON" : "OFF"));
 711         coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
 712
 713         if (!force_exec) {
 714                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 715                             "[BTCoex], bPreRfRxLpfShrink=%d, bCurRfRxLpfShrink=%d\n",
 716                             coex_dm->pre_rf_rx_lpf_shrink,
 717                             coex_dm->cur_rf_rx_lpf_shrink);
 718
 719                 if (coex_dm->pre_rf_rx_lpf_shrink ==
 720                     coex_dm->cur_rf_rx_lpf_shrink)
 721                         return;
 722         }
 723         btc8723b2ant_set_sw_rf_rx_lpf_corner(btcoexist,
 724                                              coex_dm->cur_rf_rx_lpf_shrink);
 725
 726         coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink;
 727 }
 728
 729 static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
 730                                         bool low_penalty_ra)
 731 {
 732         u8 h2c_parameter[6] = {0};
 733
 734         h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty*/
 735
 736         if (low_penalty_ra) {
 737                 h2c_parameter[1] |= BIT0;
 738                 /*normal rate except MCS7/6/5, OFDM54/48/36*/
 739                 h2c_parameter[2] = 0x00;
 740                 h2c_parameter[3] = 0xf7;  /*MCS7 or OFDM54*/
 741                 h2c_parameter[4] = 0xf8;  /*MCS6 or OFDM48*/
 742                 h2c_parameter[5] = 0xf9;  /*MCS5 or OFDM36*/
 743         }
 744
 745         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 746                     "[BTCoex], set WiFi Low-Penalty Retry: %s",
 747                     (low_penalty_ra ? "ON!!" : "OFF!!"));
 748
 749         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 750 }
 751
 752 static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
 753                                         bool force_exec, bool low_penalty_ra)
 754 {
 755         /*return; */
 756         btc_alg_dbg(ALGO_TRACE_SW,
 757                     "[BTCoex], %s turn LowPenaltyRA = %s\n",
 758                     (force_exec ? "force to" : ""), (low_penalty_ra ?
 759                                                      "ON" : "OFF"));
 760         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 761
 762         if (!force_exec) {
 763                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 764                             "[BTCoex], bPreLowPenaltyRa=%d, bCurLowPenaltyRa=%d\n",
 765                             coex_dm->pre_low_penalty_ra,
 766                             coex_dm->cur_low_penalty_ra);
 767
 768                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 769                         return;
 770         }
 771         btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra);
 772
 773         coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 774 }
 775
 776 static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
 777                                            u32 level)
 778 {
 779         u8 val = (u8) level;
 780         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 781                     "[BTCoex], Write SwDacSwing = 0x%x\n", level);
 782         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
 783 }
 784
 785 static void btc8723b2ant_set_sw_fulltime_dac_swing(struct btc_coexist *btcoex,
 786                                                    bool sw_dac_swing_on,
 787                                                    u32 sw_dac_swing_lvl)
 788 {
 789         if (sw_dac_swing_on)
 790                 btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl);
 791         else
 792                 btc8723b2ant_set_dac_swing_reg(btcoex, 0x18);
 793 }
 794
 795 static void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
 796                                    bool force_exec, bool dac_swing_on,
 797                                    u32 dac_swing_lvl)
 798 {
 799         btc_alg_dbg(ALGO_TRACE_SW,
 800                     "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
 801                     (force_exec ? "force to" : ""),
 802                     (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
 803         coex_dm->cur_dac_swing_on = dac_swing_on;
 804         coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
 805
 806         if (!force_exec) {
 807                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 808                             "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x, bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
 809                             coex_dm->pre_dac_swing_on,
 810                             coex_dm->pre_dac_swing_lvl,
 811                             coex_dm->cur_dac_swing_on,
 812                             coex_dm->cur_dac_swing_lvl);
 813
 814                 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
 815                     (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
 816                         return;
 817         }
 818         mdelay(30);
 819         btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on,
 820                                                dac_swing_lvl);
 821
 822         coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
 823         coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
 824 }
 825
 826 static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
 827                                        bool agc_table_en)
 828 {
 829         u8 rssi_adjust_val = 0;
 830
 831         /*  BB AGC Gain Table */
 832         if (agc_table_en) {
 833                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 834                             "[BTCoex], BB Agc Table On!\n");
 835                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6e1A0001);
 836                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6d1B0001);
 837                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6c1C0001);
 838                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6b1D0001);
 839                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6a1E0001);
 840                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x691F0001);
 841                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x68200001);
 842         } else {
 843                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 844                             "[BTCoex], BB Agc Table Off!\n");
 845                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001);
 846                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001);
 847                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001);
 848                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa71D0001);
 849                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa61E0001);
 850                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa51F0001);
 851                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa4200001);
 852         }
 853
 854         /* RF Gain */
 855         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
 856         if (agc_table_en) {
 857                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 858                             "[BTCoex], Agc Table On!\n");
 859                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 860                                           0xfffff, 0x38fff);
 861                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 862                                           0xfffff, 0x38ffe);
 863         } else {
 864                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 865                             "[BTCoex], Agc Table Off!\n");
 866                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 867                                           0xfffff, 0x380c3);
 868                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 869                                           0xfffff, 0x28ce6);
 870         }
 871         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
 872
 873         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
 874
 875         if (agc_table_en) {
 876                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 877                             "[BTCoex], Agc Table On!\n");
 878                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 879                                           0xfffff, 0x38fff);
 880                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 881                                           0xfffff, 0x38ffe);
 882         } else {
 883                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 884                             "[BTCoex], Agc Table Off!\n");
 885                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 886                                           0xfffff, 0x380c3);
 887                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 888                                           0xfffff, 0x28ce6);
 889         }
 890         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
 891
 892         /* set rssiAdjustVal for wifi module. */
 893         if (agc_table_en)
 894                 rssi_adjust_val = 8;
 895         btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON,
 896                            &rssi_adjust_val);
 897 }
 898
 899 static void btc8723b2ant_agc_table(struct btc_coexist *btcoexist,
 900                                    bool force_exec, bool agc_table_en)
 901 {
 902         btc_alg_dbg(ALGO_TRACE_SW,
 903                     "[BTCoex], %s %s Agc Table\n",
 904                     (force_exec ? "force to" : ""),
 905                     (agc_table_en ? "Enable" : "Disable"));
 906         coex_dm->cur_agc_table_en = agc_table_en;
 907
 908         if (!force_exec) {
 909                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 910                             "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
 911                             coex_dm->pre_agc_table_en,
 912                             coex_dm->cur_agc_table_en);
 913
 914                 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
 915                         return;
 916         }
 917         btc8723b2ant_set_agc_table(btcoexist, agc_table_en);
 918
 919         coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en;
 920 }
 921
 922 static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
 923                                         u32 val0x6c0, u32 val0x6c4,
 924                                         u32 val0x6c8, u8 val0x6cc)
 925 {
 926         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 927                     "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
 928         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 929
 930         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 931                     "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
 932         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 933
 934         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 935                     "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
 936         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 937
 938         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 939                     "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
 940         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 941 }
 942
 943 static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
 944                                     bool force_exec, u32 val0x6c0,
 945                                     u32 val0x6c4, u32 val0x6c8,
 946                                     u8 val0x6cc)
 947 {
 948         btc_alg_dbg(ALGO_TRACE_SW,
 949                     "[BTCoex], %s write Coex Table 0x6c0=0x%x, 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
 950                     force_exec ? "force to" : "",
 951                     val0x6c0, val0x6c4, val0x6c8, val0x6cc);
 952         coex_dm->cur_val0x6c0 = val0x6c0;
 953         coex_dm->cur_val0x6c4 = val0x6c4;
 954         coex_dm->cur_val0x6c8 = val0x6c8;
 955         coex_dm->cur_val0x6cc = val0x6cc;
 956
 957         if (!force_exec) {
 958                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 959                             "[BTCoex], preVal0x6c0=0x%x, preVal0x6c4=0x%x, preVal0x6c8=0x%x, preVal0x6cc=0x%x !!\n",
 960                             coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
 961                             coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
 962                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 963                             "[BTCoex], curVal0x6c0=0x%x, curVal0x6c4=0x%x, curVal0x6c8=0x%x, curVal0x6cc=0x%x !!\n",
 964                             coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
 965                             coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
 966
 967                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
 968                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
 969                     (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
 970                     (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
 971                         return;
 972         }
 973         btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
 974                                     val0x6c8, val0x6cc);
 975
 976         coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
 977         coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
 978         coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
 979         coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
 980 }
 981
 982 static void btc8723b_coex_tbl_type(struct btc_coexist *btcoexist,
 983                                    bool force_exec, u8 type)
 984 {
 985         switch (type) {
 986         case 0:
 987                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
 988                                         0x55555555, 0xffff, 0x3);
 989                 break;
 990         case 1:
 991                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
 992                                         0x5afa5afa, 0xffff, 0x3);
 993                 break;
 994         case 2:
 995                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
 996                                         0x5a5a5a5a, 0xffff, 0x3);
 997                 break;
 998         case 3:
 999                 btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
1000                                         0xaaaaaaaa, 0xffff, 0x3);
1001                 break;
1002         case 4:
1003                 btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff,
1004                                         0xffffffff, 0xffff, 0x3);
1005                 break;
1006         case 5:
1007                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
1008                                         0x5fff5fff, 0xffff, 0x3);
1009                 break;
1010         case 6:
1011                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1012                                         0x5a5a5a5a, 0xffff, 0x3);
1013                 break;
1014         case 7:
1015                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1016                                         0x5afa5afa, 0xffff, 0x3);
1017                 break;
1018         case 8:
1019                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5aea5aea,
1020                                         0x5aea5aea, 0xffff, 0x3);
1021                 break;
1022         case 9:
1023                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1024                                         0x5aea5aea, 0xffff, 0x3);
1025                 break;
1026         case 10:
1027                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1028                                         0x5aff5aff, 0xffff, 0x3);
1029                 break;
1030         case 11:
1031                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1032                                         0x5a5f5a5f, 0xffff, 0x3);
1033                 break;
1034         case 12:
1035                 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1036                                         0x5f5f5f5f, 0xffff, 0x3);
1037                 break;
1038         default:
1039                 break;
1040         }
1041 }
1042
1043 static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
1044                                                 bool enable)
1045 {
1046         u8 h2c_parameter[1] = {0};
1047
1048         if (enable)
1049                 h2c_parameter[0] |= BIT0;/* function enable*/
1050
1051         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
1052                     "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63=0x%x\n",
1053                     h2c_parameter[0]);
1054
1055         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1056 }
1057
1058 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1059                                          bool force_exec, bool enable)
1060 {
1061         btc_alg_dbg(ALGO_TRACE_FW,
1062                     "[BTCoex], %s turn Ignore WlanAct %s\n",
1063                     (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1064         coex_dm->cur_ignore_wlan_act = enable;
1065
1066         if (!force_exec) {
1067                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1068                             "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
1069                             coex_dm->pre_ignore_wlan_act,
1070                             coex_dm->cur_ignore_wlan_act);
1071
1072                 if (coex_dm->pre_ignore_wlan_act ==
1073                     coex_dm->cur_ignore_wlan_act)
1074                         return;
1075         }
1076         btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1077
1078         coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1079 }
1080
1081 static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
1082                                         u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1083 {
1084         u8 h2c_parameter[5];
1085
1086         h2c_parameter[0] = byte1;
1087         h2c_parameter[1] = byte2;
1088         h2c_parameter[2] = byte3;
1089         h2c_parameter[3] = byte4;
1090         h2c_parameter[4] = byte5;
1091
1092         coex_dm->ps_tdma_para[0] = byte1;
1093         coex_dm->ps_tdma_para[1] = byte2;
1094         coex_dm->ps_tdma_para[2] = byte3;
1095         coex_dm->ps_tdma_para[3] = byte4;
1096         coex_dm->ps_tdma_para[4] = byte5;
1097
1098         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
1099                     "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
1100                     h2c_parameter[0],
1101                     h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1102                     h2c_parameter[3] << 8 | h2c_parameter[4]);
1103
1104         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1105 }
1106
1107 static void btc8723b2ant_sw_mechanism1(struct btc_coexist *btcoexist,
1108                                        bool shrink_rx_lpf, bool low_penalty_ra,
1109                                        bool limited_dig, bool bt_lna_constrain)
1110 {
1111         btc8723b2ant_rf_shrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf);
1112         btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1113 }
1114
1115 static void btc8723b2ant_sw_mechanism2(struct btc_coexist *btcoexist,
1116                                        bool agc_table_shift, bool adc_backoff,
1117                                        bool sw_dac_swing, u32 dac_swing_lvl)
1118 {
1119         btc8723b2ant_agc_table(btcoexist, NORMAL_EXEC, agc_table_shift);
1120         btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1121                                dac_swing_lvl);
1122 }
1123
1124 static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
1125                                       u8 antpos_type, bool init_hwcfg,
1126                                       bool wifi_off)
1127 {
1128         struct btc_board_info *board_info = &btcoexist->board_info;
1129         u32 fw_ver = 0, u32tmp = 0;
1130         bool pg_ext_switch = false;
1131         bool use_ext_switch = false;
1132         u8 h2c_parameter[2] = {0};
1133
1134         btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
1135         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
1136
1137         if ((fw_ver < 0xc0000) || pg_ext_switch)
1138                 use_ext_switch = true;
1139
1140         if (init_hwcfg) {
1141                 /* 0x4c[23] = 0, 0x4c[24] = 1  Antenna control by WL/BT */
1142                 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1143                 u32tmp &= ~BIT23;
1144                 u32tmp |= BIT24;
1145                 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1146
1147                 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
1148                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
1149                 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
1150                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
1151
1152                 /* Force GNT_BT to low */
1153                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
1154
1155                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1156                         /* tell firmware "no antenna inverse" */
1157                         h2c_parameter[0] = 0;
1158                         h2c_parameter[1] = 1;  /* ext switch type */
1159                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1160                                                 h2c_parameter);
1161                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1162                 } else {
1163                         /* tell firmware "antenna inverse" */
1164                         h2c_parameter[0] = 1;
1165                         h2c_parameter[1] = 1;  /* ext switch type */
1166                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1167                                                 h2c_parameter);
1168                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1169                 }
1170         }
1171
1172         /* ext switch setting */
1173         if (use_ext_switch) {
1174                 /* fixed internal switch S1->WiFi, S0->BT */
1175                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1176                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1177                 else
1178                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1179
1180                 switch (antpos_type) {
1181                 case BTC_ANT_WIFI_AT_MAIN:
1182                         /* ext switch main at wifi */
1183                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
1184                                                            0x3, 0x1);
1185                         break;
1186                 case BTC_ANT_WIFI_AT_AUX:
1187                         /* ext switch aux at wifi */
1188                         btcoexist->btc_write_1byte_bitmask(btcoexist,
1189                                                            0x92c, 0x3, 0x2);
1190                         break;
1191                 }
1192         } else {        /* internal switch */
1193                 /* fixed ext switch */
1194                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c, 0x3, 0x1);
1195                 switch (antpos_type) {
1196                 case BTC_ANT_WIFI_AT_MAIN:
1197                         /* fixed internal switch S1->WiFi, S0->BT */
1198                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1199                         break;
1200                 case BTC_ANT_WIFI_AT_AUX:
1201                         /* fixed internal switch S0->WiFi, S1->BT */
1202                         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1203                         break;
1204                 }
1205         }
1206 }
1207
1208 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
1209                                  bool turn_on, u8 type)
1210 {
1211         btc_alg_dbg(ALGO_TRACE_FW,
1212                     "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1213                     (force_exec ? "force to" : ""),
1214                     (turn_on ? "ON" : "OFF"), type);
1215         coex_dm->cur_ps_tdma_on = turn_on;
1216         coex_dm->cur_ps_tdma = type;
1217
1218         if (!force_exec) {
1219                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1220                             "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1221                             coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1222                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1223                             "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1224                             coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1225
1226                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1227                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1228                         return;
1229         }
1230         if (turn_on) {
1231                 switch (type) {
1232                 case 1:
1233                 default:
1234                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1235                                                     0x1a, 0xe1, 0x90);
1236                         break;
1237                 case 2:
1238                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1239                                                     0x12, 0xe1, 0x90);
1240                         break;
1241                 case 3:
1242                         /* This call breaks BT when wireless is active -
1243                          * comment it out for now until a better fix is found:
1244                          * btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1245                          *                          0x3, 0xf1, 0x90);
1246                          */
1247                         break;
1248                 case 4:
1249                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1250                                                     0x03, 0xf1, 0x90);
1251                         break;
1252                 case 5:
1253                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1254                                                     0x1a, 0x60, 0x90);
1255                         break;
1256                 case 6:
1257                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1258                                                     0x12, 0x60, 0x90);
1259                         break;
1260                 case 7:
1261                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1262                                                     0x3, 0x70, 0x90);
1263                         break;
1264                 case 8:
1265                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1266                                                     0x3, 0x70, 0x90);
1267                         break;
1268                 case 9:
1269                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1270                                                     0x1a, 0xe1, 0x90);
1271                         break;
1272                 case 10:
1273                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1274                                                     0x12, 0xe1, 0x90);
1275                         break;
1276                 case 11:
1277                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1278                                                     0xa, 0xe1, 0x90);
1279                         break;
1280                 case 12:
1281                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1282                                                     0x5, 0xe1, 0x90);
1283                         break;
1284                 case 13:
1285                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1286                                                     0x1a, 0x60, 0x90);
1287                         break;
1288                 case 14:
1289                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1290                                                     0x12, 0x60, 0x90);
1291                         break;
1292                 case 15:
1293                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1294                                                     0xa, 0x60, 0x90);
1295                         break;
1296                 case 16:
1297                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1298                                                     0x5, 0x60, 0x90);
1299                         break;
1300                 case 17:
1301                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1302                                                     0x2f, 0x60, 0x90);
1303                         break;
1304                 case 18:
1305                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1306                                                     0x5, 0xe1, 0x90);
1307                         break;
1308                 case 19:
1309                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1310                                                     0x25, 0xe1, 0x90);
1311                         break;
1312                 case 20:
1313                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1314                                                     0x25, 0x60, 0x90);
1315                         break;
1316                 case 21:
1317                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1318                                                     0x03, 0x70, 0x90);
1319                         break;
1320                 case 71:
1321                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1322                                                     0x1a, 0xe1, 0x90);
1323                         break;
1324                 }
1325         } else {
1326                 /* disable PS tdma */
1327                 switch (type) {
1328                 case 0:
1329                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1330                                                     0x40, 0x0);
1331                         break;
1332                 case 1:
1333                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1334                                                     0x48, 0x0);
1335                         break;
1336                 default:
1337                         btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1338                                                     0x40, 0x0);
1339                         break;
1340                 }
1341         }
1342
1343         /* update pre state */
1344         coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1345         coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1346 }
1347
1348 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1349 {
1350         /* fw all off */
1351         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1352         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1353         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1354
1355         /* sw all off */
1356         btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1357         btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1358
1359         /* hw all off */
1360         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1361         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1362 }
1363
1364 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1365 {
1366         /* force to reset coex mechanism*/
1367
1368         btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1369         btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1370         btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, false);
1371
1372         btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1373         btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1374 }
1375
1376 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1377 {
1378         bool wifi_connected = false;
1379         bool low_pwr_disable = true;
1380
1381         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1382                            &low_pwr_disable);
1383         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1384                            &wifi_connected);
1385
1386         if (wifi_connected) {
1387                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
1388                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1389         } else {
1390                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1391                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1392         }
1393         btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1394         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1395
1396         btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1397         btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1398
1399         coex_dm->need_recover_0x948 = true;
1400         coex_dm->backup_0x948 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1401
1402         btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_AUX,
1403                                   false, false);
1404 }
1405
1406 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1407 {
1408         bool common = false, wifi_connected = false;
1409         bool wifi_busy = false;
1410         bool bt_hs_on = false, low_pwr_disable = false;
1411
1412         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1413         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1414                            &wifi_connected);
1415         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1416
1417         if (!wifi_connected) {
1418                 low_pwr_disable = false;
1419                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1420                                    &low_pwr_disable);
1421
1422                 btc_alg_dbg(ALGO_TRACE,
1423                             "[BTCoex], Wifi non-connected idle!!\n");
1424
1425                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1426                                           0x0);
1427                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1428                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1429                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1430                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1431
1432                 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false,
1433                                            false);
1434                 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false,
1435                                            0x18);
1436
1437                 common = true;
1438         } else {
1439                 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1440                     coex_dm->bt_status) {
1441                         low_pwr_disable = false;
1442                         btcoexist->btc_set(btcoexist,
1443                                            BTC_SET_ACT_DISABLE_LOW_POWER,
1444                                            &low_pwr_disable);
1445
1446                         btc_alg_dbg(ALGO_TRACE,
1447                                     "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1448
1449                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1450                                                   0xfffff, 0x0);
1451                         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1452                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1453                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1454                                                       0xb);
1455                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1456                                                 false);
1457
1458                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
1459                                                    false, false);
1460                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1461                                                    false, 0x18);
1462
1463                         common = true;
1464                 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1465                            coex_dm->bt_status) {
1466                         low_pwr_disable = true;
1467                         btcoexist->btc_set(btcoexist,
1468                                            BTC_SET_ACT_DISABLE_LOW_POWER,
1469                                            &low_pwr_disable);
1470
1471                         if (bt_hs_on)
1472                                 return false;
1473                         btc_alg_dbg(ALGO_TRACE,
1474                                     "[BTCoex], Wifi connected + BT connected-idle!!\n");
1475
1476                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1477                                                   0xfffff, 0x0);
1478                         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1479                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1480                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1481                                                       0xb);
1482                         btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1483                                                 false);
1484
1485                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
1486                                                    false, false);
1487                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1488                                                    false, 0x18);
1489
1490                         common = true;
1491                 } else {
1492                         low_pwr_disable = true;
1493                         btcoexist->btc_set(btcoexist,
1494                                            BTC_SET_ACT_DISABLE_LOW_POWER,
1495                                            &low_pwr_disable);
1496
1497                         if (wifi_busy) {
1498                                 btc_alg_dbg(ALGO_TRACE,
1499                                             "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1500                                 common = false;
1501                         } else {
1502                                 if (bt_hs_on)
1503                                         return false;
1504
1505                                 btc_alg_dbg(ALGO_TRACE,
1506                                             "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1507
1508                                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1509                                                           0x1, 0xfffff, 0x0);
1510                                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC,
1511                                                        7);
1512                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1513                                                      true, 21);
1514                                 btc8723b2ant_fw_dac_swing_lvl(btcoexist,
1515                                                               NORMAL_EXEC,
1516                                                               0xb);
1517                                 if (btc8723b_need_dec_pwr(btcoexist))
1518                                         btc8723b2ant_dec_bt_pwr(btcoexist,
1519                                                                 NORMAL_EXEC,
1520                                                                 true);
1521                                 else
1522                                         btc8723b2ant_dec_bt_pwr(btcoexist,
1523                                                                 NORMAL_EXEC,
1524                                                                 false);
1525                                 btc8723b2ant_sw_mechanism1(btcoexist, false,
1526                                                            false, false,
1527                                                            false);
1528                                 btc8723b2ant_sw_mechanism2(btcoexist, false,
1529                                                            false, false,
1530                                                            0x18);
1531                                 common = true;
1532                         }
1533                 }
1534         }
1535
1536         return common;
1537 }
1538
1539 static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause,
1540                           s32 result)
1541 {
1542         /* Set PS TDMA for max interval == 1 */
1543         if (tx_pause) {
1544                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1545                             "[BTCoex], TxPause = 1\n");
1546
1547                 if (coex_dm->cur_ps_tdma == 71) {
1548                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1549                                              true, 5);
1550                         coex_dm->tdma_adj_type = 5;
1551                 } else if (coex_dm->cur_ps_tdma == 1) {
1552                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1553                                              true, 5);
1554                         coex_dm->tdma_adj_type = 5;
1555                 } else if (coex_dm->cur_ps_tdma == 2) {
1556                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1557                                              true, 6);
1558                         coex_dm->tdma_adj_type = 6;
1559                 } else if (coex_dm->cur_ps_tdma == 3) {
1560                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1561                                              true, 7);
1562                         coex_dm->tdma_adj_type = 7;
1563                 } else if (coex_dm->cur_ps_tdma == 4) {
1564                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1565                                              true, 8);
1566                         coex_dm->tdma_adj_type = 8;
1567                 }
1568
1569                 if (coex_dm->cur_ps_tdma == 9) {
1570                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1571                                              true, 13);
1572                         coex_dm->tdma_adj_type = 13;
1573                 } else if (coex_dm->cur_ps_tdma == 10) {
1574                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1575                                              true, 14);
1576                         coex_dm->tdma_adj_type = 14;
1577                 } else if (coex_dm->cur_ps_tdma == 11) {
1578                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1579                                              true, 15);
1580                         coex_dm->tdma_adj_type = 15;
1581                 } else if (coex_dm->cur_ps_tdma == 12) {
1582                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1583                                              true, 16);
1584                         coex_dm->tdma_adj_type = 16;
1585                 }
1586
1587                 if (result == -1) {
1588                         if (coex_dm->cur_ps_tdma == 5) {
1589                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1590                                                      true, 6);
1591                                 coex_dm->tdma_adj_type = 6;
1592                         } else if (coex_dm->cur_ps_tdma == 6) {
1593                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1594                                                      true, 7);
1595                                 coex_dm->tdma_adj_type = 7;
1596                         } else if (coex_dm->cur_ps_tdma == 7) {
1597                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1598                                                      true, 8);
1599                                 coex_dm->tdma_adj_type = 8;
1600                         } else if (coex_dm->cur_ps_tdma == 13) {
1601                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1602                                                      true, 14);
1603                                 coex_dm->tdma_adj_type = 14;
1604                         } else if (coex_dm->cur_ps_tdma == 14) {
1605                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1606                                                      true, 15);
1607                                 coex_dm->tdma_adj_type = 15;
1608                         } else if (coex_dm->cur_ps_tdma == 15) {
1609                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1610                                                      true, 16);
1611                                 coex_dm->tdma_adj_type = 16;
1612                         }
1613                 }  else if (result == 1) {
1614                         if (coex_dm->cur_ps_tdma == 8) {
1615                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1616                                                      true, 7);
1617                                 coex_dm->tdma_adj_type = 7;
1618                         } else if (coex_dm->cur_ps_tdma == 7) {
1619                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1620                                                      true, 6);
1621                                 coex_dm->tdma_adj_type = 6;
1622                         } else if (coex_dm->cur_ps_tdma == 6) {
1623                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1624                                                      true, 5);
1625                                 coex_dm->tdma_adj_type = 5;
1626                         } else if (coex_dm->cur_ps_tdma == 16) {
1627                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1628                                                      true, 15);
1629                                 coex_dm->tdma_adj_type = 15;
1630                         } else if (coex_dm->cur_ps_tdma == 15) {
1631                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1632                                                      true, 14);
1633                                 coex_dm->tdma_adj_type = 14;
1634                         } else if (coex_dm->cur_ps_tdma == 14) {
1635                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1636                                                      true, 13);
1637                                 coex_dm->tdma_adj_type = 13;
1638                         }
1639                 }
1640         } else {
1641                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1642                             "[BTCoex], TxPause = 0\n");
1643                 if (coex_dm->cur_ps_tdma == 5) {
1644                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 71);
1645                         coex_dm->tdma_adj_type = 71;
1646                 } else if (coex_dm->cur_ps_tdma == 6) {
1647                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1648                         coex_dm->tdma_adj_type = 2;
1649                 } else if (coex_dm->cur_ps_tdma == 7) {
1650                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1651                         coex_dm->tdma_adj_type = 3;
1652                 } else if (coex_dm->cur_ps_tdma == 8) {
1653                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1654                         coex_dm->tdma_adj_type = 4;
1655                 }
1656
1657                 if (coex_dm->cur_ps_tdma == 13) {
1658                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
1659                         coex_dm->tdma_adj_type = 9;
1660                 } else if (coex_dm->cur_ps_tdma == 14) {
1661                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1662                         coex_dm->tdma_adj_type = 10;
1663                 } else if (coex_dm->cur_ps_tdma == 15) {
1664                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1665                         coex_dm->tdma_adj_type = 11;
1666                 } else if (coex_dm->cur_ps_tdma == 16) {
1667                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1668                         coex_dm->tdma_adj_type = 12;
1669                 }
1670
1671                 if (result == -1) {
1672                         if (coex_dm->cur_ps_tdma == 71) {
1673                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1674                                                      true, 1);
1675                                 coex_dm->tdma_adj_type = 1;
1676                         } else if (coex_dm->cur_ps_tdma == 1) {
1677                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1678                                                      true, 2);
1679                                 coex_dm->tdma_adj_type = 2;
1680                         } else if (coex_dm->cur_ps_tdma == 2) {
1681                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1682                                                      true, 3);
1683                                 coex_dm->tdma_adj_type = 3;
1684                         } else if (coex_dm->cur_ps_tdma == 3) {
1685                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1686                                                      true, 4);
1687                                 coex_dm->tdma_adj_type = 4;
1688                         } else if (coex_dm->cur_ps_tdma == 9) {
1689                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1690                                                      true, 10);
1691                                 coex_dm->tdma_adj_type = 10;
1692                         } else if (coex_dm->cur_ps_tdma == 10) {
1693                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1694                                                      true, 11);
1695                                 coex_dm->tdma_adj_type = 11;
1696                         } else if (coex_dm->cur_ps_tdma == 11) {
1697                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1698                                                      true, 12);
1699                                 coex_dm->tdma_adj_type = 12;
1700                         }
1701                 }  else if (result == 1) {
1702                         if (coex_dm->cur_ps_tdma == 4) {
1703                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1704                                                      true, 3);
1705                                 coex_dm->tdma_adj_type = 3;
1706                         } else if (coex_dm->cur_ps_tdma == 3) {
1707                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1708                                                      true, 2);
1709                                 coex_dm->tdma_adj_type = 2;
1710                         } else if (coex_dm->cur_ps_tdma == 2) {
1711                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1712                                                      true, 1);
1713                                 coex_dm->tdma_adj_type = 1;
1714                         } else if (coex_dm->cur_ps_tdma == 1) {
1715                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1716                                                      true, 71);
1717                                 coex_dm->tdma_adj_type = 71;
1718                         } else if (coex_dm->cur_ps_tdma == 12) {
1719                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1720                                                      true, 11);
1721                                 coex_dm->tdma_adj_type = 11;
1722                         } else if (coex_dm->cur_ps_tdma == 11) {
1723                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1724                                                      true, 10);
1725                                 coex_dm->tdma_adj_type = 10;
1726                         } else if (coex_dm->cur_ps_tdma == 10) {
1727                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1728                                                      true, 9);
1729                                 coex_dm->tdma_adj_type = 9;
1730                         }
1731                 }
1732         }
1733 }
1734
1735 static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause,
1736                           s32 result)
1737 {
1738         /* Set PS TDMA for max interval == 2 */
1739         if (tx_pause) {
1740                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1741                             "[BTCoex], TxPause = 1\n");
1742                 if (coex_dm->cur_ps_tdma == 1) {
1743                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1744                         coex_dm->tdma_adj_type = 6;
1745                 } else if (coex_dm->cur_ps_tdma == 2) {
1746                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1747                         coex_dm->tdma_adj_type = 6;
1748                 } else if (coex_dm->cur_ps_tdma == 3) {
1749                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1750                         coex_dm->tdma_adj_type = 7;
1751                 } else if (coex_dm->cur_ps_tdma == 4) {
1752                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1753                         coex_dm->tdma_adj_type = 8;
1754                 }
1755                 if (coex_dm->cur_ps_tdma == 9) {
1756                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1757                         coex_dm->tdma_adj_type = 14;
1758                 } else if (coex_dm->cur_ps_tdma == 10) {
1759                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1760                         coex_dm->tdma_adj_type = 14;
1761                 } else if (coex_dm->cur_ps_tdma == 11) {
1762                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1763                         coex_dm->tdma_adj_type = 15;
1764                 } else if (coex_dm->cur_ps_tdma == 12) {
1765                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1766                         coex_dm->tdma_adj_type = 16;
1767                 }
1768                 if (result == -1) {
1769                         if (coex_dm->cur_ps_tdma == 5) {
1770                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1771                                                      true, 6);
1772                                 coex_dm->tdma_adj_type = 6;
1773                         } else if (coex_dm->cur_ps_tdma == 6) {
1774                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1775                                                      true, 7);
1776                                 coex_dm->tdma_adj_type = 7;
1777                         } else if (coex_dm->cur_ps_tdma == 7) {
1778                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1779                                                      true, 8);
1780                                 coex_dm->tdma_adj_type = 8;
1781                         } else if (coex_dm->cur_ps_tdma == 13) {
1782                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1783                                                      true, 14);
1784                                 coex_dm->tdma_adj_type = 14;
1785                         } else if (coex_dm->cur_ps_tdma == 14) {
1786                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1787                                                      true, 15);
1788                                 coex_dm->tdma_adj_type = 15;
1789                         } else if (coex_dm->cur_ps_tdma == 15) {
1790                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1791                                                      true, 16);
1792                                 coex_dm->tdma_adj_type = 16;
1793                         }
1794                 }  else if (result == 1) {
1795                         if (coex_dm->cur_ps_tdma == 8) {
1796                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1797                                                      true, 7);
1798                                 coex_dm->tdma_adj_type = 7;
1799                         } else if (coex_dm->cur_ps_tdma == 7) {
1800                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1801                                                      true, 6);
1802                                 coex_dm->tdma_adj_type = 6;
1803                         } else if (coex_dm->cur_ps_tdma == 6) {
1804                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1805                                                      true, 6);
1806                                 coex_dm->tdma_adj_type = 6;
1807                         } else if (coex_dm->cur_ps_tdma == 16) {
1808                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1809                                                      true, 15);
1810                                 coex_dm->tdma_adj_type = 15;
1811                         } else if (coex_dm->cur_ps_tdma == 15) {
1812                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1813                                                      true, 14);
1814                                 coex_dm->tdma_adj_type = 14;
1815                         } else if (coex_dm->cur_ps_tdma == 14) {
1816                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1817                                                      true, 14);
1818                                 coex_dm->tdma_adj_type = 14;
1819                         }
1820                 }
1821         } else {
1822                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1823                             "[BTCoex], TxPause = 0\n");
1824                 if (coex_dm->cur_ps_tdma == 5) {
1825                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1826                         coex_dm->tdma_adj_type = 2;
1827                 } else if (coex_dm->cur_ps_tdma == 6) {
1828                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1829                         coex_dm->tdma_adj_type = 2;
1830                 } else if (coex_dm->cur_ps_tdma == 7) {
1831                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1832                         coex_dm->tdma_adj_type = 3;
1833                 } else if (coex_dm->cur_ps_tdma == 8) {
1834                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1835                         coex_dm->tdma_adj_type = 4;
1836                 }
1837                 if (coex_dm->cur_ps_tdma == 13) {
1838                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1839                         coex_dm->tdma_adj_type = 10;
1840                 } else if (coex_dm->cur_ps_tdma == 14) {
1841                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1842                         coex_dm->tdma_adj_type = 10;
1843                 } else if (coex_dm->cur_ps_tdma == 15) {
1844                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1845                         coex_dm->tdma_adj_type = 11;
1846                 } else if (coex_dm->cur_ps_tdma == 16) {
1847                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1848                         coex_dm->tdma_adj_type = 12;
1849                 }
1850                 if (result == -1) {
1851                         if (coex_dm->cur_ps_tdma == 1) {
1852                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1853                                                      true, 2);
1854                                 coex_dm->tdma_adj_type = 2;
1855                         } else if (coex_dm->cur_ps_tdma == 2) {
1856                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1857                                                      true, 3);
1858                                 coex_dm->tdma_adj_type = 3;
1859                         } else if (coex_dm->cur_ps_tdma == 3) {
1860                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1861                                                      true, 4);
1862                                 coex_dm->tdma_adj_type = 4;
1863                         } else if (coex_dm->cur_ps_tdma == 9) {
1864                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1865                                                      true, 10);
1866                                 coex_dm->tdma_adj_type = 10;
1867                         } else if (coex_dm->cur_ps_tdma == 10) {
1868                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1869                                                      true, 11);
1870                                 coex_dm->tdma_adj_type = 11;
1871                         } else if (coex_dm->cur_ps_tdma == 11) {
1872                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1873                                                      true, 12);
1874                                 coex_dm->tdma_adj_type = 12;
1875                         }
1876                 } else if (result == 1) {
1877                         if (coex_dm->cur_ps_tdma == 4) {
1878                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1879                                                      true, 3);
1880                                 coex_dm->tdma_adj_type = 3;
1881                         } else if (coex_dm->cur_ps_tdma == 3) {
1882                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1883                                                      true, 2);
1884                                 coex_dm->tdma_adj_type = 2;
1885                         } else if (coex_dm->cur_ps_tdma == 2) {
1886                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1887                                                      true, 2);
1888                                 coex_dm->tdma_adj_type = 2;
1889                         } else if (coex_dm->cur_ps_tdma == 12) {
1890                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1891                                                      true, 11);
1892                                 coex_dm->tdma_adj_type = 11;
1893                         } else if (coex_dm->cur_ps_tdma == 11) {
1894                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1895                                                      true, 10);
1896                                 coex_dm->tdma_adj_type = 10;
1897                         } else if (coex_dm->cur_ps_tdma == 10) {
1898                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1899                                                      true, 10);
1900                                 coex_dm->tdma_adj_type = 10;
1901                         }
1902                 }
1903         }
1904 }
1905
1906 static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause,
1907                           s32 result)
1908 {
1909         /* Set PS TDMA for max interval == 3 */
1910         if (tx_pause) {
1911                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1912                             "[BTCoex], TxPause = 1\n");
1913                 if (coex_dm->cur_ps_tdma == 1) {
1914                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1915                         coex_dm->tdma_adj_type = 7;
1916                 } else if (coex_dm->cur_ps_tdma == 2) {
1917                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1918                         coex_dm->tdma_adj_type = 7;
1919                 } else if (coex_dm->cur_ps_tdma == 3) {
1920                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1921                         coex_dm->tdma_adj_type = 7;
1922                 } else if (coex_dm->cur_ps_tdma == 4) {
1923                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1924                         coex_dm->tdma_adj_type = 8;
1925                 }
1926                 if (coex_dm->cur_ps_tdma == 9) {
1927                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1928                         coex_dm->tdma_adj_type = 15;
1929                 } else if (coex_dm->cur_ps_tdma == 10) {
1930                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1931                         coex_dm->tdma_adj_type = 15;
1932                 } else if (coex_dm->cur_ps_tdma == 11) {
1933                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1934                         coex_dm->tdma_adj_type = 15;
1935                 } else if (coex_dm->cur_ps_tdma == 12) {
1936                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1937                         coex_dm->tdma_adj_type = 16;
1938                 }
1939                 if (result == -1) {
1940                         if (coex_dm->cur_ps_tdma == 5) {
1941                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1942                                                      true, 7);
1943                                 coex_dm->tdma_adj_type = 7;
1944                         } else if (coex_dm->cur_ps_tdma == 6) {
1945                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1946                                                      true, 7);
1947                                 coex_dm->tdma_adj_type = 7;
1948                         } else if (coex_dm->cur_ps_tdma == 7) {
1949                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1950                                                      true, 8);
1951                                 coex_dm->tdma_adj_type = 8;
1952                         } else if (coex_dm->cur_ps_tdma == 13) {
1953                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1954                                                      true, 15);
1955                                 coex_dm->tdma_adj_type = 15;
1956                         } else if (coex_dm->cur_ps_tdma == 14) {
1957                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1958                                                      true, 15);
1959                                 coex_dm->tdma_adj_type = 15;
1960                         } else if (coex_dm->cur_ps_tdma == 15) {
1961                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1962                                                      true, 16);
1963                                 coex_dm->tdma_adj_type = 16;
1964                         }
1965                 }  else if (result == 1) {
1966                         if (coex_dm->cur_ps_tdma == 8) {
1967                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1968                                                      true, 7);
1969                                 coex_dm->tdma_adj_type = 7;
1970                         } else if (coex_dm->cur_ps_tdma == 7) {
1971                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1972                                                      true, 7);
1973                                 coex_dm->tdma_adj_type = 7;
1974                         } else if (coex_dm->cur_ps_tdma == 6) {
1975                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1976                                                      true, 7);
1977                                 coex_dm->tdma_adj_type = 7;
1978                         } else if (coex_dm->cur_ps_tdma == 16) {
1979                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1980                                                      true, 15);
1981                                 coex_dm->tdma_adj_type = 15;
1982                         } else if (coex_dm->cur_ps_tdma == 15) {
1983                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1984                                                      true, 15);
1985                                 coex_dm->tdma_adj_type = 15;
1986                         } else if (coex_dm->cur_ps_tdma == 14) {
1987                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1988                                                      true, 15);
1989                                 coex_dm->tdma_adj_type = 15;
1990                         }
1991                 }
1992         } else {
1993                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1994                             "[BTCoex], TxPause = 0\n");
1995                 if (coex_dm->cur_ps_tdma == 5) {
1996                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1997                         coex_dm->tdma_adj_type = 3;
1998                 } else if (coex_dm->cur_ps_tdma == 6) {
1999                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2000                         coex_dm->tdma_adj_type = 3;
2001                 } else if (coex_dm->cur_ps_tdma == 7) {
2002                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2003                         coex_dm->tdma_adj_type = 3;
2004                 } else if (coex_dm->cur_ps_tdma == 8) {
2005                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
2006                         coex_dm->tdma_adj_type = 4;
2007                 }
2008                 if (coex_dm->cur_ps_tdma == 13) {
2009                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2010                         coex_dm->tdma_adj_type = 11;
2011                 } else if (coex_dm->cur_ps_tdma == 14) {
2012                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2013                         coex_dm->tdma_adj_type = 11;
2014                 } else if (coex_dm->cur_ps_tdma == 15) {
2015                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2016                         coex_dm->tdma_adj_type = 11;
2017                 } else if (coex_dm->cur_ps_tdma == 16) {
2018                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
2019                         coex_dm->tdma_adj_type = 12;
2020                 }
2021                 if (result == -1) {
2022                         if (coex_dm->cur_ps_tdma == 1) {
2023                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2024                                                      true, 3);
2025                                 coex_dm->tdma_adj_type = 3;
2026                         } else if (coex_dm->cur_ps_tdma == 2) {
2027                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2028                                                      true, 3);
2029                                 coex_dm->tdma_adj_type = 3;
2030                         } else if (coex_dm->cur_ps_tdma == 3) {
2031                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2032                                                      true, 4);
2033                                 coex_dm->tdma_adj_type = 4;
2034                         } else if (coex_dm->cur_ps_tdma == 9) {
2035                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2036                                                      true, 11);
2037                                 coex_dm->tdma_adj_type = 11;
2038                         } else if (coex_dm->cur_ps_tdma == 10) {
2039                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2040                                                      true, 11);
2041                                 coex_dm->tdma_adj_type = 11;
2042                         } else if (coex_dm->cur_ps_tdma == 11) {
2043                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2044                                                      true, 12);
2045                                 coex_dm->tdma_adj_type = 12;
2046                         }
2047                 } else if (result == 1) {
2048                         if (coex_dm->cur_ps_tdma == 4) {
2049                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2050                                                      true, 3);
2051                                 coex_dm->tdma_adj_type = 3;
2052                         } else if (coex_dm->cur_ps_tdma == 3) {
2053                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2054                                                      true, 3);
2055                                 coex_dm->tdma_adj_type = 3;
2056                         } else if (coex_dm->cur_ps_tdma == 2) {
2057                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2058                                                      true, 3);
2059                                 coex_dm->tdma_adj_type = 3;
2060                         } else if (coex_dm->cur_ps_tdma == 12) {
2061                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2062                                                      true, 11);
2063                                 coex_dm->tdma_adj_type = 11;
2064                         } else if (coex_dm->cur_ps_tdma == 11) {
2065                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2066                                                      true, 11);
2067                                 coex_dm->tdma_adj_type = 11;
2068                         } else if (coex_dm->cur_ps_tdma == 10) {
2069                                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2070                                                      true, 11);
2071                                 coex_dm->tdma_adj_type = 11;
2072                         }
2073                 }
2074         }
2075 }
2076
2077 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
2078                                           bool sco_hid, bool tx_pause,
2079                                           u8 max_interval)
2080 {
2081         static s32 up, dn, m, n, wait_count;
2082         /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
2083         s32 result;
2084         u8 retry_count = 0;
2085
2086         btc_alg_dbg(ALGO_TRACE_FW,
2087                     "[BTCoex], TdmaDurationAdjust()\n");
2088
2089         if (!coex_dm->auto_tdma_adjust) {
2090                 coex_dm->auto_tdma_adjust = true;
2091                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2092                             "[BTCoex], first run TdmaDurationAdjust()!!\n");
2093                 if (sco_hid) {
2094                         if (tx_pause) {
2095                                 if (max_interval == 1) {
2096                                         btc8723b2ant_ps_tdma(btcoexist,
2097                                                              NORMAL_EXEC,
2098                                                              true, 13);
2099                                         coex_dm->tdma_adj_type = 13;
2100                                 } else if (max_interval == 2) {
2101                                         btc8723b2ant_ps_tdma(btcoexist,
2102                                                              NORMAL_EXEC,
2103                                                              true, 14);
2104                                         coex_dm->tdma_adj_type = 14;
2105                                 } else if (max_interval == 3) {
2106                                         btc8723b2ant_ps_tdma(btcoexist,
2107                                                              NORMAL_EXEC,
2108                                                              true, 15);
2109                                         coex_dm->tdma_adj_type = 15;
2110                                 } else {
2111                                         btc8723b2ant_ps_tdma(btcoexist,
2112                                                              NORMAL_EXEC,
2113                                                              true, 15);
2114                                         coex_dm->tdma_adj_type = 15;
2115                                 }
2116                         } else {
2117                                 if (max_interval == 1) {
2118                                         btc8723b2ant_ps_tdma(btcoexist,
2119                                                              NORMAL_EXEC,
2120                                                              true, 9);
2121                                         coex_dm->tdma_adj_type = 9;
2122                                 } else if (max_interval == 2) {
2123                                         btc8723b2ant_ps_tdma(btcoexist,
2124                                                              NORMAL_EXEC,
2125                                                              true, 10);
2126                                         coex_dm->tdma_adj_type = 10;
2127                                 } else if (max_interval == 3) {
2128                                         btc8723b2ant_ps_tdma(btcoexist,
2129                                                              NORMAL_EXEC,
2130                                                              true, 11);
2131                                         coex_dm->tdma_adj_type = 11;
2132                                 } else {
2133                                         btc8723b2ant_ps_tdma(btcoexist,
2134                                                              NORMAL_EXEC,
2135                                                              true, 11);
2136                                         coex_dm->tdma_adj_type = 11;
2137                                 }
2138                         }
2139                 } else {
2140                         if (tx_pause) {
2141                                 if (max_interval == 1) {
2142                                         btc8723b2ant_ps_tdma(btcoexist,
2143                                                              NORMAL_EXEC,
2144                                                              true, 5);
2145                                         coex_dm->tdma_adj_type = 5;
2146                                 } else if (max_interval == 2) {
2147                                         btc8723b2ant_ps_tdma(btcoexist,
2148                                                              NORMAL_EXEC,
2149                                                              true, 6);
2150                                         coex_dm->tdma_adj_type = 6;
2151                                 } else if (max_interval == 3) {
2152                                         btc8723b2ant_ps_tdma(btcoexist,
2153                                                              NORMAL_EXEC,
2154                                                              true, 7);
2155                                         coex_dm->tdma_adj_type = 7;
2156                                 } else {
2157                                         btc8723b2ant_ps_tdma(btcoexist,
2158                                                              NORMAL_EXEC,
2159                                                              true, 7);
2160                                         coex_dm->tdma_adj_type = 7;
2161                                 }
2162                         } else {
2163                                 if (max_interval == 1) {
2164                                         btc8723b2ant_ps_tdma(btcoexist,
2165                                                              NORMAL_EXEC,
2166                                                              true, 1);
2167                                         coex_dm->tdma_adj_type = 1;
2168                                 } else if (max_interval == 2) {
2169                                         btc8723b2ant_ps_tdma(btcoexist,
2170                                                              NORMAL_EXEC,
2171                                                              true, 2);
2172                                         coex_dm->tdma_adj_type = 2;
2173                                 } else if (max_interval == 3) {
2174                                         btc8723b2ant_ps_tdma(btcoexist,
2175                                                              NORMAL_EXEC,
2176                                                              true, 3);
2177                                         coex_dm->tdma_adj_type = 3;
2178                                 } else {
2179                                         btc8723b2ant_ps_tdma(btcoexist,
2180                                                              NORMAL_EXEC,
2181                                                              true, 3);
2182                                         coex_dm->tdma_adj_type = 3;
2183                                 }
2184                         }
2185                 }
2186
2187                 up = 0;
2188                 dn = 0;
2189                 m = 1;
2190                 n = 3;
2191                 result = 0;
2192                 wait_count = 0;
2193         } else {
2194                 /*accquire the BT TRx retry count from BT_Info byte2*/
2195                 retry_count = coex_sta->bt_retry_cnt;
2196                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2197                             "[BTCoex], retry_count = %d\n", retry_count);
2198                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2199                             "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
2200                             up, dn, m, n, wait_count);
2201                 result = 0;
2202                 wait_count++;
2203                  /* no retry in the last 2-second duration*/
2204                 if (retry_count == 0) {
2205                         up++;
2206                         dn--;
2207
2208                         if (dn <= 0)
2209                                 dn = 0;
2210
2211                         if (up >= n) {
2212                                 wait_count = 0;
2213                                 n = 3;
2214                                 up = 0;
2215                                 dn = 0;
2216                                 result = 1;
2217                                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2218                                             "[BTCoex], Increase wifi duration!!\n");
2219                         } /* <=3 retry in the last 2-second duration*/
2220                 } else if (retry_count <= 3) {
2221                         up--;
2222                         dn++;
2223
2224                         if (up <= 0)
2225                                 up = 0;
2226
2227                         if (dn == 2) {
2228                                 if (wait_count <= 2)
2229                                         m++;
2230                                 else
2231                                         m = 1;
2232
2233                                 if (m >= 20)
2234                                         m = 20;
2235
2236                                 n = 3 * m;
2237                                 up = 0;
2238                                 dn = 0;
2239                                 wait_count = 0;
2240                                 result = -1;
2241                                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2242                                             "[BTCoex], Decrease wifi duration for retry_counter<3!!\n");
2243                         }
2244                 } else {
2245                         if (wait_count == 1)
2246                                 m++;
2247                         else
2248                                 m = 1;
2249
2250                         if (m >= 20)
2251                                 m = 20;
2252
2253                         n = 3 * m;
2254                         up = 0;
2255                         dn = 0;
2256                         wait_count = 0;
2257                         result = -1;
2258                         btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2259                                     "[BTCoex], Decrease wifi duration for retry_counter>3!!\n");
2260                 }
2261
2262                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2263                             "[BTCoex], max Interval = %d\n", max_interval);
2264                 if (max_interval == 1)
2265                         set_tdma_int1(btcoexist, tx_pause, result);
2266                 else if (max_interval == 2)
2267                         set_tdma_int2(btcoexist, tx_pause, result);
2268                 else if (max_interval == 3)
2269                         set_tdma_int3(btcoexist, tx_pause, result);
2270         }
2271
2272         /*if current PsTdma not match with the recorded one (when scan, dhcp..),
2273          *then we have to adjust it back to the previous recorded one.
2274          */
2275         if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
2276                 bool scan = false, link = false, roam = false;
2277                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2278                             "[BTCoex], PsTdma type dismatch!!!, curPsTdma=%d, recordPsTdma=%d\n",
2279                             coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
2280
2281                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2282                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2283                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2284
2285                 if (!scan && !link && !roam)
2286                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2287                                              coex_dm->tdma_adj_type);
2288                 else
2289                         btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2290                                     "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2291         }
2292 }
2293
2294 /* SCO only or SCO+PAN(HS) */
2295 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2296 {
2297         u8 wifi_rssi_state;
2298         u32 wifi_bw;
2299
2300         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2301                                                        0, 2, 15, 0);
2302
2303         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2304
2305         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2306
2307         if (btc8723b_need_dec_pwr(btcoexist))
2308                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2309         else
2310                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2311
2312         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2313
2314         /*for SCO quality at 11b/g mode*/
2315         if (BTC_WIFI_BW_LEGACY == wifi_bw)
2316                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 2);
2317         else  /*for SCO quality & wifi performance balance at 11n mode*/
2318                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 8);
2319
2320         /*for voice quality */
2321         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2322
2323         /* sw mechanism */
2324         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2325                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2326                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2327                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2328                                                    false, false);
2329                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2330                                                    true, 0x4);
2331                 } else {
2332                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2333                                                    false, false);
2334                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2335                                                    true, 0x4);
2336                 }
2337         } else {
2338                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2339                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2340                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2341                                                    false, false);
2342                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2343                                                    true, 0x4);
2344                 } else {
2345                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2346                                                    false, false);
2347                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2348                                                    true, 0x4);
2349                 }
2350         }
2351 }
2352
2353 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2354 {
2355         u8 wifi_rssi_state, bt_rssi_state;
2356         u32 wifi_bw;
2357
2358         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2359                                                        0, 2, 15, 0);
2360         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2361
2362         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2363
2364         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2365
2366         if (btc8723b_need_dec_pwr(btcoexist))
2367                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2368         else
2369                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2370
2371         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2372
2373         if (BTC_WIFI_BW_LEGACY == wifi_bw) /*/for HID at 11b/g mode*/
2374                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2375         else  /*for HID quality & wifi performance balance at 11n mode*/
2376                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 9);
2377
2378         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2379             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2380                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2381         else
2382                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2383
2384         /* sw mechanism */
2385         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2386                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2387                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2388                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2389                                                    false, false);
2390                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2391                                                    false, 0x18);
2392                 } else {
2393                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2394                                                    false, false);
2395                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2396                                                    false, 0x18);
2397                 }
2398         } else {
2399                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2400                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2401                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2402                                                    false, false);
2403                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2404                                                    false, 0x18);
2405                 } else {
2406                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2407                                                    false, false);
2408                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2409                                                    false, 0x18);
2410                 }
2411         }
2412 }
2413
2414 /*A2DP only / PAN(EDR) only/ A2DP+PAN(HS)*/
2415 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2416 {
2417         u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2418         u32 wifi_bw;
2419         u8 ap_num = 0;
2420
2421         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2422                                                        0, 2, 15, 0);
2423         wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist,
2424                                                         1, 2, 40, 0);
2425         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2426
2427         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
2428
2429         /* define the office environment */
2430         /* driver don't know AP num in Linux, so we will never enter this if */
2431         if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) {
2432                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2433                                           0x0);
2434                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2435                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2436                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
2437                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2438
2439                 /* sw mechanism */
2440                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2441                 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2442                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2443                                                    false, false);
2444                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2445                                                    true, 0x18);
2446                 } else {
2447                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2448                                                    false, false);
2449                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2450                                                    true, 0x18);
2451                 }
2452                 return;
2453         }
2454
2455         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2456
2457         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2458
2459         if (btc8723b_need_dec_pwr(btcoexist))
2460                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2461         else
2462                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2463
2464         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2465
2466         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2467             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2468                 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2469                                                   false, 1);
2470         else
2471                 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2472
2473         /* sw mechanism */
2474         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2475         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2476                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2477                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2478                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2479                                                    false, false);
2480                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2481                                                    false, 0x18);
2482                 } else {
2483                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2484                                                    false, false);
2485                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2486                                                    false, 0x18);
2487                 }
2488         } else {
2489                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2490                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2491                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2492                                                    false, false);
2493                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2494                                                    false, 0x18);
2495                 } else {
2496                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2497                                                    false, false);
2498                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2499                                                    false, 0x18);
2500                 }
2501         }
2502 }
2503
2504 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2505 {
2506         u8 wifi_rssi_state;
2507         u32 wifi_bw;
2508
2509         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2510                                                        0, 2, 15, 0);
2511
2512         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2513
2514         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2515
2516         if (btc8723b_need_dec_pwr(btcoexist))
2517                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2518         else
2519                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2520
2521         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2522
2523         btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2524
2525         /* sw mechanism */
2526         btcoexist->btc_get(btcoexist,
2527                 BTC_GET_U4_WIFI_BW, &wifi_bw);
2528         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2529                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2530                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2531                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2532                                                    false, false);
2533                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2534                                                    false, 0x18);
2535                 } else {
2536                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2537                                                    false, false);
2538                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2539                                                    false, 0x18);
2540                 }
2541         } else {
2542                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2543                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2544                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2545                                                    false, false);
2546                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2547                                                    false, 0x18);
2548                 } else {
2549                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2550                                                    false, false);
2551                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2552                                                    false, 0x18);
2553                 }
2554         }
2555 }
2556
2557 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
2558 {
2559         u8 wifi_rssi_state, bt_rssi_state;
2560         u32 wifi_bw;
2561
2562         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2563                                                        0, 2, 15, 0);
2564         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2565
2566         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2567
2568         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2569
2570         if (btc8723b_need_dec_pwr(btcoexist))
2571                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2572         else
2573                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2574
2575         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 10);
2576
2577         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2578             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2579                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2580         else
2581                 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2582
2583         /* sw mechanism */
2584         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2585         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2586                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2587                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2588                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2589                                                    false, false);
2590                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2591                                                    false, 0x18);
2592                 } else {
2593                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2594                                                    false, false);
2595                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2596                                                    false, 0x18);
2597                 }
2598         } else {
2599                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2600                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2601                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2602                                                    false, false);
2603                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2604                                                    false, 0x18);
2605                 } else {
2606                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2607                                                    false, false);
2608                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2609                                                    false, 0x18);
2610                 }
2611         }
2612 }
2613
2614 /*PAN(HS) only*/
2615 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
2616 {
2617         u8 wifi_rssi_state;
2618         u32 wifi_bw;
2619
2620         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2621                                                        0, 2, 15, 0);
2622
2623         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2624
2625         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2626
2627         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2628             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2629                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2630         else
2631                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2632
2633         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2634
2635         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2636
2637         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2638         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2639                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2640                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2641                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2642                                                    false, false);
2643                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2644                                                    false, 0x18);
2645                 } else {
2646                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2647                                                    false, false);
2648                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2649                                                    false, 0x18);
2650                 }
2651         } else {
2652                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2653                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2654                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2655                                                    false, false);
2656                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2657                                                    false, 0x18);
2658                 } else {
2659                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2660                                                    false, false);
2661                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2662                                                    false, 0x18);
2663                 }
2664         }
2665 }
2666
2667 /*PAN(EDR)+A2DP*/
2668 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
2669 {
2670         u8 wifi_rssi_state, bt_rssi_state;
2671         u32 wifi_bw;
2672
2673         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2674                                                        0, 2, 15, 0);
2675         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2676
2677         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2678
2679         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2680
2681         if (btc8723b_need_dec_pwr(btcoexist))
2682                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2683         else
2684                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2685
2686         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2687
2688         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2689             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2690                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 12);
2691                 if (BTC_WIFI_BW_HT40 == wifi_bw)
2692                         btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2693                                                           true, 3);
2694                 else
2695                         btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2696                                                           false, 3);
2697         } else {
2698                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2699                 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 3);
2700         }
2701
2702         /* sw mechanism */
2703         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2704                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2705                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2706                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2707                                                    false, false);
2708                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2709                                                    false, 0x18);
2710                 } else {
2711                         btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2712                                                    false, false);
2713                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2714                                                    false, 0x18);
2715                 }
2716         } else {
2717                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2718                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2719                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2720                                                    false, false);
2721                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2722                                                    false, 0x18);
2723                 } else {
2724                         btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2725                                                    false, false);
2726                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2727                                                    false, 0x18);
2728                 }
2729         }
2730 }
2731
2732 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
2733 {
2734         u8 wifi_rssi_state, bt_rssi_state;
2735         u32 wifi_bw;
2736
2737         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2738                                                        0, 2, 15, 0);
2739         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2740         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2741
2742         if (btc8723b_need_dec_pwr(btcoexist))
2743                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2744         else
2745                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2746
2747         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2748             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2749                 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2750                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2751                                                       3);
2752                         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2753                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2754                                                   0xfffff, 0x780);
2755                 } else {
2756                         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2757                                                       6);
2758                         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2759                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2760                                                   0xfffff, 0x0);
2761                 }
2762                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2763         } else {
2764                 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2765                 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2766                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2767                                           0x0);
2768                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2769         }
2770
2771         /* sw mechanism */
2772         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2773                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2774                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2775                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2776                                                    false, false);
2777                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2778                                                    false, 0x18);
2779                 } else {
2780                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2781                                                    false, false);
2782                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2783                                                    false, 0x18);
2784                 }
2785         } else {
2786                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2787                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2788                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2789                                                    false, false);
2790                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2791                                                    false, 0x18);
2792                 } else {
2793                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2794                                                    false, false);
2795                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2796                                                    false, 0x18);
2797                 }
2798         }
2799 }
2800
2801 /* HID+A2DP+PAN(EDR) */
2802 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
2803 {
2804         u8 wifi_rssi_state, bt_rssi_state;
2805         u32 wifi_bw;
2806
2807         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2808                                                        0, 2, 15, 0);
2809         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2810
2811         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2812
2813         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2814
2815         if (btc8723b_need_dec_pwr(btcoexist))
2816                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2817         else
2818                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2819
2820         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2821
2822         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2823
2824         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2825             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2826                 if (BTC_WIFI_BW_HT40 == wifi_bw)
2827                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2828                                                           true, 2);
2829                 else
2830                         btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2831                                                           false, 3);
2832         } else {
2833                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
2834         }
2835
2836         /* sw mechanism */
2837         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2838                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2839                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2840                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2841                                                    false, false);
2842                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2843                                                    false, 0x18);
2844                 } else {
2845                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2846                                                    false, false);
2847                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2848                                                    false, 0x18);
2849                 }
2850         } else {
2851                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2852                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2853                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2854                                                    false, false);
2855                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2856                                                    false, 0x18);
2857                 } else {
2858                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2859                                                    false, false);
2860                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2861                                                    false, 0x18);
2862                 }
2863         }
2864 }
2865
2866 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
2867 {
2868         u8 wifi_rssi_state, bt_rssi_state;
2869         u32 wifi_bw;
2870
2871         wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2872                                                        0, 2, 15, 0);
2873         bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2874
2875         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2876
2877         btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2878
2879         if (btc8723b_need_dec_pwr(btcoexist))
2880                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2881         else
2882                 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2883
2884         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2885
2886         btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2887
2888         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2889             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2890                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2891         else
2892                 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2893
2894         /* sw mechanism */
2895         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2896                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2897                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2898                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2899                                                    false, false);
2900                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2901                                                    false, 0x18);
2902                 } else {
2903                         btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2904                                                    false, false);
2905                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2906                                                    false, 0x18);
2907                 }
2908         } else {
2909                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2910                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2911                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2912                                                    false, false);
2913                         btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2914                                                    false, 0x18);
2915                 } else {
2916                         btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2917                                                    false, false);
2918                         btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2919                                                    false, 0x18);
2920                 }
2921         }
2922 }
2923
2924 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
2925 {
2926         u8 algorithm = 0;
2927
2928         btc_alg_dbg(ALGO_TRACE,
2929                     "[BTCoex], RunCoexistMechanism()===>\n");
2930
2931         if (btcoexist->manual_control) {
2932                 btc_alg_dbg(ALGO_TRACE,
2933                             "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
2934                 return;
2935         }
2936
2937         if (coex_sta->under_ips) {
2938                 btc_alg_dbg(ALGO_TRACE,
2939                             "[BTCoex], wifi is under IPS !!!\n");
2940                 return;
2941         }
2942
2943         algorithm = btc8723b2ant_action_algorithm(btcoexist);
2944         if (coex_sta->c2h_bt_inquiry_page &&
2945             (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
2946                 btc_alg_dbg(ALGO_TRACE,
2947                             "[BTCoex], BT is under inquiry/page scan !!\n");
2948                 btc8723b2ant_action_bt_inquiry(btcoexist);
2949                 return;
2950         } else {
2951                 if (coex_dm->need_recover_0x948) {
2952                         coex_dm->need_recover_0x948 = false;
2953                         btcoexist->btc_write_2byte(btcoexist, 0x948,
2954                                                    coex_dm->backup_0x948);
2955                 }
2956         }
2957
2958         coex_dm->cur_algorithm = algorithm;
2959         btc_alg_dbg(ALGO_TRACE, "[BTCoex], Algorithm = %d\n",
2960                     coex_dm->cur_algorithm);
2961
2962         if (btc8723b2ant_is_common_action(btcoexist)) {
2963                 btc_alg_dbg(ALGO_TRACE,
2964                             "[BTCoex], Action 2-Ant common\n");
2965                 coex_dm->auto_tdma_adjust = false;
2966         } else {
2967                 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
2968                         btc_alg_dbg(ALGO_TRACE,
2969                                     "[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n",
2970                                     coex_dm->pre_algorithm,
2971                                     coex_dm->cur_algorithm);
2972                         coex_dm->auto_tdma_adjust = false;
2973                 }
2974                 switch (coex_dm->cur_algorithm) {
2975                 case BT_8723B_2ANT_COEX_ALGO_SCO:
2976                         btc_alg_dbg(ALGO_TRACE,
2977                                     "[BTCoex], Action 2-Ant, algorithm = SCO\n");
2978                         btc8723b2ant_action_sco(btcoexist);
2979                         break;
2980                 case BT_8723B_2ANT_COEX_ALGO_HID:
2981                         btc_alg_dbg(ALGO_TRACE,
2982                                     "[BTCoex], Action 2-Ant, algorithm = HID\n");
2983                         btc8723b2ant_action_hid(btcoexist);
2984                         break;
2985                 case BT_8723B_2ANT_COEX_ALGO_A2DP:
2986                         btc_alg_dbg(ALGO_TRACE,
2987                                     "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
2988                         btc8723b2ant_action_a2dp(btcoexist);
2989                         break;
2990                 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
2991                         btc_alg_dbg(ALGO_TRACE,
2992                                     "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
2993                         btc8723b2ant_action_a2dp_pan_hs(btcoexist);
2994                         break;
2995                 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
2996                         btc_alg_dbg(ALGO_TRACE,
2997                                     "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
2998                         btc8723b2ant_action_pan_edr(btcoexist);
2999                         break;
3000                 case BT_8723B_2ANT_COEX_ALGO_PANHS:
3001                         btc_alg_dbg(ALGO_TRACE,
3002                                     "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3003                         btc8723b2ant_action_pan_hs(btcoexist);
3004                         break;
3005                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
3006                         btc_alg_dbg(ALGO_TRACE,
3007                                     "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3008                         btc8723b2ant_action_pan_edr_a2dp(btcoexist);
3009                         break;
3010                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
3011                         btc_alg_dbg(ALGO_TRACE,
3012                                     "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3013                         btc8723b2ant_action_pan_edr_hid(btcoexist);
3014                         break;
3015                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3016                         btc_alg_dbg(ALGO_TRACE,
3017                                     "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3018                         btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
3019                         break;
3020                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
3021                         btc_alg_dbg(ALGO_TRACE,
3022                                     "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3023                         btc8723b2ant_action_hid_a2dp(btcoexist);
3024                         break;
3025                 default:
3026                         btc_alg_dbg(ALGO_TRACE,
3027                                     "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3028                         btc8723b2ant_coex_alloff(btcoexist);
3029                         break;
3030                 }
3031                 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3032         }
3033 }
3034
3035 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist)
3036 {
3037         /* set wlan_act to low */
3038         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3039         /* Force GNT_BT to High */
3040         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3);
3041         /* BT select s0/s1 is controlled by BT */
3042         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
3043 }
3044
3045 /*********************************************************************
3046  *  work around function start with wa_btc8723b2ant_
3047  *********************************************************************/
3048 /*********************************************************************
3049  *  extern function start with EXbtc8723b2ant_
3050  *********************************************************************/
3051 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
3052 {
3053         u8 u8tmp = 0;
3054
3055         btc_iface_dbg(INTF_INIT,
3056                       "[BTCoex], 2Ant Init HW Config!!\n");
3057         coex_dm->bt_rf0x1e_backup =
3058                 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3059
3060         /* 0x790[5:0] = 0x5 */
3061         u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3062         u8tmp &= 0xc0;
3063         u8tmp |= 0x5;
3064         btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3065
3066         /*Antenna config */
3067         btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
3068                                   true, false);
3069         /* PTA parameter */
3070         btc8723b_coex_tbl_type(btcoexist, FORCE_EXEC, 0);
3071
3072         /* Enable counter statistics */
3073         /*0x76e[3] =1, WLAN_Act control by PTA*/
3074         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
3075         btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3076         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3077 }
3078
3079 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3080 {
3081         btc_iface_dbg(INTF_INIT,
3082                       "[BTCoex], Coex Mechanism Init!!\n");
3083         btc8723b2ant_init_coex_dm(btcoexist);
3084 }
3085
3086 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
3087 {
3088         struct btc_board_info *board_info = &btcoexist->board_info;
3089         struct btc_stack_info *stack_info = &btcoexist->stack_info;
3090         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3091         struct rtl_priv *rtlpriv = btcoexist->adapter;
3092         u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3093         u32 u32tmp[4];
3094         bool roam = false, scan = false;
3095         bool link = false, wifi_under_5g = false;
3096         bool bt_hs_on = false, wifi_busy = false;
3097         s32 wifi_rssi = 0, bt_hs_rssi = 0;
3098         u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3099         u8 wifi_dot11_chnl, wifi_hs_chnl;
3100         u32 fw_ver = 0, bt_patch_ver = 0;
3101         u8 ap_num = 0;
3102
3103         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3104                    "\r\n ============[BT Coexist info]============");
3105
3106         if (btcoexist->manual_control) {
3107                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3108                            "\r\n ==========[Under Manual Control]============");
3109                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3110                            "\r\n ==========================================");
3111         }
3112
3113         if (!board_info->bt_exist) {
3114                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3115                 return;
3116         }
3117
3118         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3119                    "Ant PG number/ Ant mechanism:",
3120                    board_info->pg_ant_num, board_info->btdm_ant_num);
3121
3122         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
3123                    "BT stack/ hci ext ver",
3124                    ((stack_info->profile_notified) ? "Yes" : "No"),
3125                    stack_info->hci_version);
3126
3127         btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3128         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3129         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3130                    "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3131                    "CoexVer/ FwVer/ PatchVer",
3132                    glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3133                    fw_ver, bt_patch_ver, bt_patch_ver);
3134
3135         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3136         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3137                            &wifi_dot11_chnl);
3138         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3139
3140         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
3141                    "Dot11 channel / HsChnl(HsMode)",
3142                    wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3143
3144         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %3ph ",
3145                    "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info);
3146
3147         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3148         btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3149         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3150         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d",
3151                    "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num);
3152
3153         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3154         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3155         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3156         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3157                    "Wifi link/ roam/ scan", link, roam, scan);
3158
3159         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3160         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3161         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3162         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3163                            &wifi_traffic_dir);
3164         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
3165                    "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3166                    ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3167                    (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3168                    ((!wifi_busy) ? "idle" :
3169                    ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3170                    "uplink" : "downlink")));
3171
3172
3173         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d",
3174                    "SCO/HID/PAN/A2DP",
3175                    bt_link_info->sco_exist, bt_link_info->hid_exist,
3176                    bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3177         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3178
3179         bt_info_ext = coex_sta->bt_info_ext;
3180         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3181                    "BT Info A2DP rate",
3182                    (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3183
3184         for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3185                 if (coex_sta->bt_info_c2h_cnt[i]) {
3186                         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3187                                    "\r\n %-35s = %7ph(%d)",
3188                                    glbt_info_src_8723b_2ant[i],
3189                                    coex_sta->bt_info_c2h[i],
3190                                    coex_sta->bt_info_c2h_cnt[i]);
3191                 }
3192         }
3193
3194         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3195                    "PS state, IPS/LPS",
3196                    ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3197                    ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3198         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3199
3200         /* Sw mechanism */
3201         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3202                    "\r\n %-35s", "============[Sw mechanism]============");
3203         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3204                    "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3205                    coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3206         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3207                    "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3208                    coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3209                    coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3210
3211         /* Fw mechanism */
3212         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3213                    "============[Fw mechanism]============");
3214
3215         ps_tdma_case = coex_dm->cur_ps_tdma;
3216         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3217                    "\r\n %-35s = %5ph case-%d (auto:%d)",
3218                    "PS TDMA", coex_dm->ps_tdma_para,
3219                    ps_tdma_case, coex_dm->auto_tdma_adjust);
3220
3221         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3222                    "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr,
3223                    coex_dm->cur_ignore_wlan_act);
3224
3225         /* Hw setting */
3226         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3227                    "============[Hw setting]============");
3228
3229         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3230                    "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3231
3232         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3233         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3234         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3235                    "0x778/0x880[29:25]", u8tmp[0],
3236                    (u32tmp[0]&0x3e000000) >> 25);
3237
3238         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3239         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3240         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3241         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3242                    "0x948/ 0x67[5] / 0x765",
3243                    u32tmp[0], ((u8tmp[0]&0x20) >> 5), u8tmp[1]);
3244
3245         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3246         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3247         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3248         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3249                    "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3250                    u32tmp[0]&0x3, u32tmp[1]&0xff, u32tmp[2]&0x3);
3251
3252         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3253         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3254         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3255         u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3256         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3257                    "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3258                    "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3259                    ((u8tmp[0] & 0x8)>>3), u8tmp[1],
3260                    ((u32tmp[0]&0x01800000)>>23), u8tmp[2]&0x1);
3261
3262         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3263         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3264         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3265                    "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3266
3267         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3268         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3269         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3270                    "0xc50(dig)/0x49c(null-drop)", u32tmp[0]&0xff, u8tmp[0]);
3271
3272         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3273         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3274         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3275         u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3276
3277         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3278         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3279
3280         fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3281                   ((u32tmp[1]&0xffff0000) >> 16) +
3282                    (u32tmp[1] & 0xffff) +
3283                    (u32tmp[2] & 0xffff) +
3284                   ((u32tmp[3]&0xffff0000) >> 16) +
3285                    (u32tmp[3] & 0xffff);
3286         fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3287
3288         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3289                    "OFDM-CCA/OFDM-FA/CCK-FA",
3290                    u32tmp[0]&0xffff, fa_ofdm, fa_cck);
3291
3292         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3293         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3294         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3295         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3296         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3297                    "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3298                    "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3299                    u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3300
3301         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3302                    "0x770(high-pri rx/tx)",
3303                    coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3304         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3305                    "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
3306                    coex_sta->low_priority_tx);
3307 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1)
3308         btc8723b2ant_monitor_bt_ctr(btcoexist);
3309 #endif
3310         btcoexist->btc_disp_dbg_msg(btcoexist,
3311         BTC_DBG_DISP_COEX_STATISTICS);
3312 }
3313
3314 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3315 {
3316         if (BTC_IPS_ENTER == type) {
3317                 btc_iface_dbg(INTF_NOTIFY,
3318                               "[BTCoex], IPS ENTER notify\n");
3319                 coex_sta->under_ips = true;
3320                 btc8723b2ant_wifioff_hwcfg(btcoexist);
3321                 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3322                 btc8723b2ant_coex_alloff(btcoexist);
3323         } else if (BTC_IPS_LEAVE == type) {
3324                 btc_iface_dbg(INTF_NOTIFY,
3325                               "[BTCoex], IPS LEAVE notify\n");
3326                 coex_sta->under_ips = false;
3327                 ex_btc8723b2ant_init_hwconfig(btcoexist);
3328                 btc8723b2ant_init_coex_dm(btcoexist);
3329                 btc8723b2ant_query_bt_info(btcoexist);
3330         }
3331 }
3332
3333 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3334 {
3335         if (BTC_LPS_ENABLE == type) {
3336                 btc_iface_dbg(INTF_NOTIFY,
3337                               "[BTCoex], LPS ENABLE notify\n");
3338                 coex_sta->under_lps = true;
3339         } else if (BTC_LPS_DISABLE == type) {
3340                 btc_iface_dbg(INTF_NOTIFY,
3341                               "[BTCoex], LPS DISABLE notify\n");
3342                 coex_sta->under_lps = false;
3343         }
3344 }
3345
3346 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3347 {
3348         if (BTC_SCAN_START == type)
3349                 btc_iface_dbg(INTF_NOTIFY,
3350                               "[BTCoex], SCAN START notify\n");
3351         else if (BTC_SCAN_FINISH == type)
3352                 btc_iface_dbg(INTF_NOTIFY,
3353                               "[BTCoex], SCAN FINISH notify\n");
3354 }
3355
3356 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3357 {
3358         if (BTC_ASSOCIATE_START == type)
3359                 btc_iface_dbg(INTF_NOTIFY,
3360                               "[BTCoex], CONNECT START notify\n");
3361         else if (BTC_ASSOCIATE_FINISH == type)
3362                 btc_iface_dbg(INTF_NOTIFY,
3363                               "[BTCoex], CONNECT FINISH notify\n");
3364 }
3365
3366 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
3367                                          u8 type)
3368 {
3369         u8 h2c_parameter[3] = {0};
3370         u32 wifi_bw;
3371         u8 wifi_central_chnl;
3372
3373         if (BTC_MEDIA_CONNECT == type)
3374                 btc_iface_dbg(INTF_NOTIFY,
3375                               "[BTCoex], MEDIA connect notify\n");
3376         else
3377                 btc_iface_dbg(INTF_NOTIFY,
3378                               "[BTCoex], MEDIA disconnect notify\n");
3379
3380         /* only 2.4G we need to inform bt the chnl mask */
3381         btcoexist->btc_get(btcoexist,
3382                 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
3383         if ((BTC_MEDIA_CONNECT == type) &&
3384             (wifi_central_chnl <= 14)) {
3385                 h2c_parameter[0] = 0x1;
3386                 h2c_parameter[1] = wifi_central_chnl;
3387                 btcoexist->btc_get(btcoexist,
3388                         BTC_GET_U4_WIFI_BW, &wifi_bw);
3389                 if (BTC_WIFI_BW_HT40 == wifi_bw)
3390                         h2c_parameter[2] = 0x30;
3391                 else
3392                         h2c_parameter[2] = 0x20;
3393         }
3394
3395         coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3396         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3397         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3398
3399         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
3400                     "[BTCoex], FW write 0x66=0x%x\n",
3401                     h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3402                     h2c_parameter[2]);
3403
3404         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3405 }
3406
3407 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
3408                                            u8 type)
3409 {
3410         if (type == BTC_PACKET_DHCP)
3411                 btc_iface_dbg(INTF_NOTIFY,
3412                               "[BTCoex], DHCP Packet notify\n");
3413 }
3414
3415 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
3416                                     u8 *tmpbuf, u8 length)
3417 {
3418         u8 bt_info = 0;
3419         u8 i, rsp_source = 0;
3420         bool bt_busy = false, limited_dig = false;
3421         bool wifi_connected = false;
3422
3423         coex_sta->c2h_bt_info_req_sent = false;
3424
3425         rsp_source = tmpbuf[0]&0xf;
3426         if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
3427                 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3428         coex_sta->bt_info_c2h_cnt[rsp_source]++;
3429
3430         btc_iface_dbg(INTF_NOTIFY,
3431                       "[BTCoex], Bt info[%d], length=%d, hex data=[",
3432                       rsp_source, length);
3433         for (i = 0; i < length; i++) {
3434                 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
3435                 if (i == 1)
3436                         bt_info = tmpbuf[i];
3437                 if (i == length-1)
3438                         btc_iface_dbg(INTF_NOTIFY,
3439                                       "0x%02x]\n", tmpbuf[i]);
3440                 else
3441                         btc_iface_dbg(INTF_NOTIFY,
3442                                       "0x%02x, ", tmpbuf[i]);
3443         }
3444
3445         if (btcoexist->manual_control) {
3446                 btc_alg_dbg(ALGO_TRACE,
3447                             "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
3448                 return;
3449         }
3450
3451         if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
3452                 coex_sta->bt_retry_cnt =        /* [3:0]*/
3453                         coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3454
3455                 coex_sta->bt_rssi =
3456                         coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
3457
3458                 coex_sta->bt_info_ext =
3459                         coex_sta->bt_info_c2h[rsp_source][4];
3460
3461                 /* Here we need to resend some wifi info to BT
3462                      because bt is reset and loss of the info.
3463                  */
3464                 if ((coex_sta->bt_info_ext & BIT1)) {
3465                         btc_alg_dbg(ALGO_TRACE,
3466                                     "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
3467                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3468                                            &wifi_connected);
3469                         if (wifi_connected)
3470                                 ex_btc8723b2ant_media_status_notify(
3471                                                         btcoexist,
3472                                                         BTC_MEDIA_CONNECT);
3473                         else
3474                                 ex_btc8723b2ant_media_status_notify(
3475                                                         btcoexist,
3476                                                         BTC_MEDIA_DISCONNECT);
3477                 }
3478
3479                 if ((coex_sta->bt_info_ext & BIT3)) {
3480                         btc_alg_dbg(ALGO_TRACE,
3481                                     "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
3482                         btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
3483                                                      false);
3484                 } else {
3485                         /* BT already NOT ignore Wlan active, do nothing here.*/
3486                 }
3487 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3488                 if ((coex_sta->bt_info_ext & BIT4)) {
3489                         /* BT auto report already enabled, do nothing*/
3490                 } else {
3491                         btc8723b2ant_bt_auto_report(btcoexist, FORCE_EXEC,
3492                                                     true);
3493                 }
3494 #endif
3495         }
3496
3497         /* check BIT2 first ==> check if bt is under inquiry or page scan*/
3498         if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
3499                 coex_sta->c2h_bt_inquiry_page = true;
3500         else
3501                 coex_sta->c2h_bt_inquiry_page = false;
3502
3503         /* set link exist status*/
3504         if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3505                 coex_sta->bt_link_exist = false;
3506                 coex_sta->pan_exist = false;
3507                 coex_sta->a2dp_exist = false;
3508                 coex_sta->hid_exist = false;
3509                 coex_sta->sco_exist = false;
3510         } else { /* connection exists */
3511                 coex_sta->bt_link_exist = true;
3512                 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
3513                         coex_sta->pan_exist = true;
3514                 else
3515                         coex_sta->pan_exist = false;
3516                 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
3517                         coex_sta->a2dp_exist = true;
3518                 else
3519                         coex_sta->a2dp_exist = false;
3520                 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
3521                         coex_sta->hid_exist = true;
3522                 else
3523                         coex_sta->hid_exist = false;
3524                 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
3525                         coex_sta->sco_exist = true;
3526                 else
3527                         coex_sta->sco_exist = false;
3528         }
3529
3530         btc8723b2ant_update_bt_link_info(btcoexist);
3531
3532         if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3533                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3534                 btc_alg_dbg(ALGO_TRACE,
3535                             "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
3536         /* connection exists but no busy */
3537         } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
3538                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
3539                 btc_alg_dbg(ALGO_TRACE,
3540                             "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3541         } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
3542                    (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
3543                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
3544                 btc_alg_dbg(ALGO_TRACE,
3545                             "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3546         } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
3547                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
3548                 btc_alg_dbg(ALGO_TRACE,
3549                             "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3550         } else {
3551                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
3552                 btc_alg_dbg(ALGO_TRACE,
3553                             "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
3554         }
3555
3556         if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3557             (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3558             (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
3559                 bt_busy = true;
3560                 limited_dig = true;
3561         } else {
3562                 bt_busy = false;
3563                 limited_dig = false;
3564         }
3565
3566         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3567
3568         coex_dm->limited_dig = limited_dig;
3569         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
3570
3571         btc8723b2ant_run_coexist_mechanism(btcoexist);
3572 }
3573
3574 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
3575 {
3576         btc_iface_dbg(INTF_NOTIFY, "[BTCoex], Halt notify\n");
3577
3578         btc8723b2ant_wifioff_hwcfg(btcoexist);
3579         btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3580         ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3581 }
3582
3583 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
3584 {
3585         struct btc_board_info *board_info = &btcoexist->board_info;
3586         struct btc_stack_info *stack_info = &btcoexist->stack_info;
3587         static u8 dis_ver_info_cnt;
3588         u32 fw_ver = 0, bt_patch_ver = 0;
3589
3590         btc_alg_dbg(ALGO_TRACE,
3591                     "[BTCoex], ==========================Periodical===========================\n");
3592
3593         if (dis_ver_info_cnt <= 5) {
3594                 dis_ver_info_cnt += 1;
3595                 btc_iface_dbg(INTF_INIT,
3596                               "[BTCoex], ****************************************************************\n");
3597                 btc_iface_dbg(INTF_INIT,
3598                               "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
3599                               board_info->pg_ant_num,
3600                               board_info->btdm_ant_num,
3601                               board_info->btdm_ant_pos);
3602                 btc_iface_dbg(INTF_INIT,
3603                               "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3604                               stack_info->profile_notified ? "Yes" : "No",
3605                               stack_info->hci_version);
3606                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3607                                    &bt_patch_ver);
3608                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3609                 btc_iface_dbg(INTF_INIT,
3610                               "[BTCoex], CoexVer/ fw_ver/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3611                               glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3612                               fw_ver, bt_patch_ver, bt_patch_ver);
3613                 btc_iface_dbg(INTF_INIT,
3614                               "[BTCoex], ****************************************************************\n");
3615         }
3616
3617 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3618         btc8723b2ant_query_bt_info(btcoexist);
3619         btc8723b2ant_monitor_bt_ctr(btcoexist);
3620         btc8723b2ant_monitor_bt_enable_disable(btcoexist);
3621 #else
3622         if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
3623             coex_dm->auto_tdma_adjust)
3624                 btc8723b2ant_run_coexist_mechanism(btcoexist);
3625 #endif
3626 }