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