drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b1ant.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 /***************************************************************
  27  * Description:
  28  *
  29  * This file is for RTL8723B Co-exist mechanism
  30  *
  31  * History
  32  * 2012/11/15 Cosa first check in.
  33  *
  34  ***************************************************************/
  35
  36 /***************************************************************
  37  * include files
  38  ***************************************************************/
  39 #include "halbt_precomp.h"
  40 /***************************************************************
  41  * Global variables, these are static variables
  42  ***************************************************************/
  43 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant;
  44 static struct coex_dm_8723b_1ant *coex_dm = &glcoex_dm_8723b_1ant;
  45 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant;
  46 static struct coex_sta_8723b_1ant *coex_sta = &glcoex_sta_8723b_1ant;
  47
  48 static const char *const glbt_info_src_8723b_1ant[] = {
  49         "BT Info[wifi fw]",
  50         "BT Info[bt rsp]",
  51         "BT Info[bt auto report]",
  52 };
  53
  54 static u32 glcoex_ver_date_8723b_1ant = 20130918;
  55 static u32 glcoex_ver_8723b_1ant = 0x47;
  56
  57 /***************************************************************
  58  * local function proto type if needed
  59  ***************************************************************/
  60 /***************************************************************
  61  * local function start with halbtc8723b1ant_
  62  ***************************************************************/
  63
  64 static void halbtc8723b1ant_updatera_mask(struct btc_coexist *btcoexist,
  65                                           bool force_exec, u32 dis_rate_mask)
  66 {
  67         coex_dm->curra_mask = dis_rate_mask;
  68
  69         if (force_exec || (coex_dm->prera_mask != coex_dm->curra_mask))
  70                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
  71                                    &coex_dm->curra_mask);
  72
  73         coex_dm->prera_mask = coex_dm->curra_mask;
  74 }
  75
  76 static void btc8723b1ant_auto_rate_fb_retry(struct btc_coexist *btcoexist,
  77                                             bool force_exec, u8 type)
  78 {
  79         bool wifi_under_bmode = false;
  80
  81         coex_dm->cur_arfr_type = type;
  82
  83         if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
  84                 switch (coex_dm->cur_arfr_type) {
  85                 case 0: /* normal mode */
  86                         btcoexist->btc_write_4byte(btcoexist, 0x430,
  87                                                    coex_dm->backup_arfr_cnt1);
  88                         btcoexist->btc_write_4byte(btcoexist, 0x434,
  89                                                    coex_dm->backup_arfr_cnt2);
  90                         break;
  91                 case 1:
  92                         btcoexist->btc_get(btcoexist,
  93                                            BTC_GET_BL_WIFI_UNDER_B_MODE,
  94                                            &wifi_under_bmode);
  95                         if (wifi_under_bmode) {
  96                                 btcoexist->btc_write_4byte(btcoexist,
  97                                                            0x430, 0x0);
  98                                 btcoexist->btc_write_4byte(btcoexist,
  99                                                            0x434, 0x01010101);
 100                         } else {
 101                                 btcoexist->btc_write_4byte(btcoexist,
 102                                                            0x430, 0x0);
 103                                 btcoexist->btc_write_4byte(btcoexist,
 104                                                            0x434, 0x04030201);
 105                         }
 106                         break;
 107                 default:
 108                         break;
 109                 }
 110         }
 111
 112         coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
 113 }
 114
 115 static void halbtc8723b1ant_retry_limit(struct btc_coexist *btcoexist,
 116                                         bool force_exec, u8 type)
 117 {
 118         coex_dm->cur_retry_limit_type = type;
 119
 120         if (force_exec || (coex_dm->pre_retry_limit_type !=
 121                            coex_dm->cur_retry_limit_type)) {
 122                 switch (coex_dm->cur_retry_limit_type) {
 123                 case 0: /* normal mode */
 124                         btcoexist->btc_write_2byte(btcoexist, 0x42a,
 125                                                    coex_dm->backup_retry_limit);
 126                         break;
 127                 case 1: /* retry limit = 8 */
 128                         btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
 129                         break;
 130                 default:
 131                         break;
 132                 }
 133         }
 134
 135         coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
 136 }
 137
 138 static void halbtc8723b1ant_ampdu_maxtime(struct btc_coexist *btcoexist,
 139                                           bool force_exec, u8 type)
 140 {
 141         coex_dm->cur_ampdu_time_type = type;
 142
 143         if (force_exec || (coex_dm->pre_ampdu_time_type !=
 144                 coex_dm->cur_ampdu_time_type)) {
 145                 switch (coex_dm->cur_ampdu_time_type) {
 146                 case 0: /* normal mode */
 147                         btcoexist->btc_write_1byte(btcoexist, 0x456,
 148                                         coex_dm->backup_ampdu_max_time);
 149                         break;
 150                 case 1: /* AMPDU timw = 0x38 * 32us */
 151                         btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
 152                         break;
 153                 default:
 154                         break;
 155                 }
 156         }
 157
 158         coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
 159 }
 160
 161 static void halbtc8723b1ant_limited_tx(struct btc_coexist *btcoexist,
 162                                        bool force_exec, u8 ra_masktype,
 163                                        u8 arfr_type, u8 retry_limit_type,
 164                                        u8 ampdu_time_type)
 165 {
 166         switch (ra_masktype) {
 167         case 0: /* normal mode */
 168                 halbtc8723b1ant_updatera_mask(btcoexist, force_exec, 0x0);
 169                 break;
 170         case 1: /* disable cck 1/2 */
 171                 halbtc8723b1ant_updatera_mask(btcoexist, force_exec,
 172                                               0x00000003);
 173                 break;
 174         /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
 175         case 2:
 176                 halbtc8723b1ant_updatera_mask(btcoexist, force_exec,
 177                                               0x0001f1f7);
 178                 break;
 179         default:
 180                 break;
 181         }
 182
 183         btc8723b1ant_auto_rate_fb_retry(btcoexist, force_exec, arfr_type);
 184         halbtc8723b1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
 185         halbtc8723b1ant_ampdu_maxtime(btcoexist, force_exec, ampdu_time_type);
 186 }
 187
 188 static void halbtc8723b1ant_limited_rx(struct btc_coexist *btcoexist,
 189                                        bool force_exec, bool rej_ap_agg_pkt,
 190                                        bool bt_ctrl_agg_buf_size,
 191                                        u8 agg_buf_size)
 192 {
 193         bool reject_rx_agg = rej_ap_agg_pkt;
 194         bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
 195         u8 rxaggsize = agg_buf_size;
 196
 197         /**********************************************
 198          *      Rx Aggregation related setting
 199          **********************************************/
 200         btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
 201                            &reject_rx_agg);
 202         /* decide BT control aggregation buf size or not  */
 203         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
 204                            &bt_ctrl_rx_agg_size);
 205         /* aggregation buf size, only work
 206          * when BT control Rx aggregation size.
 207          */
 208         btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxaggsize);
 209         /* real update aggregation setting  */
 210         btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 211 }
 212
 213 static void halbtc8723b1ant_query_bt_info(struct btc_coexist *btcoexist)
 214 {
 215         u8 h2c_parameter[1] = {0};
 216
 217         coex_sta->c2h_bt_info_req_sent = true;
 218
 219         /* trigger */
 220         h2c_parameter[0] |= BIT(0);
 221
 222         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 223 }
 224
 225 static void halbtc8723b1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
 226 {
 227         u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
 228         u32 reg_hp_tx = 0, reg_hp_rx = 0;
 229         u32 reg_lp_tx = 0, reg_lp_rx = 0;
 230         static u32 num_of_bt_counter_chk;
 231
 232         reg_hp_txrx = 0x770;
 233         reg_lp_txrx = 0x774;
 234
 235         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
 236         reg_hp_tx = u32tmp & MASKLWORD;
 237         reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
 238
 239         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
 240         reg_lp_tx = u32tmp & MASKLWORD;
 241         reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
 242
 243         coex_sta->high_priority_tx = reg_hp_tx;
 244         coex_sta->high_priority_rx = reg_hp_rx;
 245         coex_sta->low_priority_tx = reg_lp_tx;
 246         coex_sta->low_priority_rx = reg_lp_rx;
 247
 248         if ((coex_sta->low_priority_tx > 1050) &&
 249             (!coex_sta->c2h_bt_inquiry_page))
 250                 coex_sta->pop_event_cnt++;
 251
 252         /* reset counter */
 253         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 254
 255         /* This part is for wifi FW and driver to update BT's status as
 256          * disabled.
 257          *
 258          * The flow is as the following
 259          * 1. disable BT
 260          * 2. if all BT Tx/Rx counter = 0, after 6 sec we query bt info
 261          * 3. Because BT will not rsp from mailbox, so wifi fw will know BT is
 262          * disabled
 263          *
 264          * 4. FW will rsp c2h for BT that driver will know BT is disabled.
 265          */
 266         if ((reg_hp_tx == 0) && (reg_hp_rx == 0) && (reg_lp_tx == 0) &&
 267             (reg_lp_rx == 0)) {
 268                 num_of_bt_counter_chk++;
 269                 if (num_of_bt_counter_chk == 3)
 270                         halbtc8723b1ant_query_bt_info(btcoexist);
 271         } else {
 272                 num_of_bt_counter_chk = 0;
 273         }
 274 }
 275
 276 static void halbtc8723b1ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
 277 {
 278         s32 wifi_rssi = 0;
 279         bool wifi_busy = false, wifi_under_b_mode = false;
 280         static u8 cck_lock_counter;
 281         u32 total_cnt;
 282
 283         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 284         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 285         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
 286                            &wifi_under_b_mode);
 287
 288         if (coex_sta->under_ips) {
 289                 coex_sta->crc_ok_cck = 0;
 290                 coex_sta->crc_ok_11g = 0;
 291                 coex_sta->crc_ok_11n = 0;
 292                 coex_sta->crc_ok_11n_agg = 0;
 293
 294                 coex_sta->crc_err_cck = 0;
 295                 coex_sta->crc_err_11g = 0;
 296                 coex_sta->crc_err_11n = 0;
 297                 coex_sta->crc_err_11n_agg = 0;
 298         } else {
 299                 coex_sta->crc_ok_cck =
 300                         btcoexist->btc_read_4byte(btcoexist, 0xf88);
 301                 coex_sta->crc_ok_11g =
 302                         btcoexist->btc_read_2byte(btcoexist, 0xf94);
 303                 coex_sta->crc_ok_11n =
 304                         btcoexist->btc_read_2byte(btcoexist, 0xf90);
 305                 coex_sta->crc_ok_11n_agg =
 306                         btcoexist->btc_read_2byte(btcoexist, 0xfb8);
 307
 308                 coex_sta->crc_err_cck =
 309                         btcoexist->btc_read_4byte(btcoexist, 0xf84);
 310                 coex_sta->crc_err_11g =
 311                         btcoexist->btc_read_2byte(btcoexist, 0xf96);
 312                 coex_sta->crc_err_11n =
 313                         btcoexist->btc_read_2byte(btcoexist, 0xf92);
 314                 coex_sta->crc_err_11n_agg =
 315                         btcoexist->btc_read_2byte(btcoexist, 0xfba);
 316         }
 317
 318         /* reset counter */
 319         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
 320         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
 321
 322         if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
 323                 total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
 324                             coex_sta->crc_ok_11n + coex_sta->crc_ok_11n_agg;
 325
 326                 if ((coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
 327                     (coex_dm->bt_status ==
 328                      BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
 329                     (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY)) {
 330                         if (coex_sta->crc_ok_cck >
 331                             (total_cnt - coex_sta->crc_ok_cck)) {
 332                                 if (cck_lock_counter < 3)
 333                                         cck_lock_counter++;
 334                         } else {
 335                                 if (cck_lock_counter > 0)
 336                                         cck_lock_counter--;
 337                         }
 338
 339                 } else {
 340                         if (cck_lock_counter > 0)
 341                                 cck_lock_counter--;
 342                 }
 343         } else {
 344                 if (cck_lock_counter > 0)
 345                         cck_lock_counter--;
 346         }
 347
 348         if (!coex_sta->pre_ccklock) {
 349                 if (cck_lock_counter >= 3)
 350                         coex_sta->cck_lock = true;
 351                 else
 352                         coex_sta->cck_lock = false;
 353         } else {
 354                 if (cck_lock_counter == 0)
 355                         coex_sta->cck_lock = false;
 356                 else
 357                         coex_sta->cck_lock = true;
 358         }
 359
 360         if (coex_sta->cck_lock)
 361                 coex_sta->cck_ever_lock = true;
 362
 363         coex_sta->pre_ccklock = coex_sta->cck_lock;
 364 }
 365
 366 static bool btc8723b1ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
 367 {
 368         static bool pre_wifi_busy;
 369         static bool pre_under_4way, pre_bt_hs_on;
 370         bool wifi_busy = false, under_4way = false, bt_hs_on = false;
 371         bool wifi_connected = false;
 372
 373         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 374                            &wifi_connected);
 375         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 376         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 377         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
 378                            &under_4way);
 379
 380         if (wifi_connected) {
 381                 if (wifi_busy != pre_wifi_busy) {
 382                         pre_wifi_busy = wifi_busy;
 383                         return true;
 384                 }
 385                 if (under_4way != pre_under_4way) {
 386                         pre_under_4way = under_4way;
 387                         return true;
 388                 }
 389                 if (bt_hs_on != pre_bt_hs_on) {
 390                         pre_bt_hs_on = bt_hs_on;
 391                         return true;
 392                 }
 393         }
 394
 395         return false;
 396 }
 397
 398 static void halbtc8723b1ant_update_bt_link_info(struct btc_coexist *btcoexist)
 399 {
 400         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 401         bool bt_hs_on = false;
 402
 403         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 404
 405         bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
 406         bt_link_info->sco_exist = coex_sta->sco_exist;
 407         bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
 408         bt_link_info->pan_exist = coex_sta->pan_exist;
 409         bt_link_info->hid_exist = coex_sta->hid_exist;
 410         bt_link_info->bt_hi_pri_link_exist = coex_sta->bt_hi_pri_link_exist;
 411
 412         /* work around for HS mode. */
 413         if (bt_hs_on) {
 414                 bt_link_info->pan_exist = true;
 415                 bt_link_info->bt_link_exist = true;
 416         }
 417
 418         /* check if Sco only */
 419         if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 420             !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 421                 bt_link_info->sco_only = true;
 422         else
 423                 bt_link_info->sco_only = false;
 424
 425         /* check if A2dp only */
 426         if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
 427             !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 428                 bt_link_info->a2dp_only = true;
 429         else
 430                 bt_link_info->a2dp_only = false;
 431
 432         /* check if Pan only */
 433         if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 434             bt_link_info->pan_exist && !bt_link_info->hid_exist)
 435                 bt_link_info->pan_only = true;
 436         else
 437                 bt_link_info->pan_only = false;
 438
 439         /* check if Hid only */
 440         if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 441             !bt_link_info->pan_exist && bt_link_info->hid_exist)
 442                 bt_link_info->hid_only = true;
 443         else
 444                 bt_link_info->hid_only = false;
 445 }
 446
 447 static void halbtc8723b1ant_set_bt_auto_report(struct btc_coexist *btcoexist,
 448                                                bool enable_auto_report)
 449 {
 450         u8 h2c_parameter[1] = {0};
 451
 452         h2c_parameter[0] = 0;
 453
 454         if (enable_auto_report)
 455                 h2c_parameter[0] |= BIT(0);
 456
 457         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 458 }
 459
 460 static void halbtc8723b1ant_bt_auto_report(struct btc_coexist *btcoexist,
 461                                            bool force_exec,
 462                                            bool enable_auto_report)
 463 {
 464         coex_dm->cur_bt_auto_report = enable_auto_report;
 465
 466         if (!force_exec) {
 467                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
 468                         return;
 469         }
 470         halbtc8723b1ant_set_bt_auto_report(btcoexist,
 471                                            coex_dm->cur_bt_auto_report);
 472
 473         coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
 474 }
 475
 476 static void btc8723b1ant_set_sw_pen_tx_rate_adapt(struct btc_coexist *btcoexist,
 477                                                   bool low_penalty_ra)
 478 {
 479         struct rtl_priv *rtlpriv = btcoexist->adapter;
 480         u8 h2c_parameter[6] = {0};
 481
 482         h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty */
 483
 484         if (low_penalty_ra) {
 485                 h2c_parameter[1] |= BIT0;
 486                 /* normal rate except MCS7/6/5, OFDM54/48/36 */
 487                 h2c_parameter[2] = 0x00;
 488                 h2c_parameter[3] = 0xf7;  /* MCS7 or OFDM54 */
 489                 h2c_parameter[4] = 0xf8;  /* MCS6 or OFDM48 */
 490                 h2c_parameter[5] = 0xf9;  /* MCS5 or OFDM36 */
 491         }
 492
 493         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 494                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
 495                  (low_penalty_ra ? "ON!!" : "OFF!!"));
 496
 497         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 498 }
 499
 500 static void halbtc8723b1ant_low_penalty_ra(struct btc_coexist *btcoexist,
 501                                            bool force_exec, bool low_penalty_ra)
 502 {
 503         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 504
 505         if (!force_exec) {
 506                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 507                         return;
 508         }
 509         btc8723b1ant_set_sw_pen_tx_rate_adapt(btcoexist,
 510                                               coex_dm->cur_low_penalty_ra);
 511
 512         coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 513 }
 514
 515 static void halbtc8723b1ant_set_coex_table(struct btc_coexist *btcoexist,
 516                                            u32 val0x6c0, u32 val0x6c4,
 517                                            u32 val0x6c8, u8 val0x6cc)
 518 {
 519         struct rtl_priv *rtlpriv = btcoexist->adapter;
 520
 521         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 522                  "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
 523         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 524
 525         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 526                  "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
 527         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 528
 529         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 530                  "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
 531         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 532
 533         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 534                  "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
 535         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 536 }
 537
 538 static void halbtc8723b1ant_coex_table(struct btc_coexist *btcoexist,
 539                                        bool force_exec, u32 val0x6c0,
 540                                        u32 val0x6c4, u32 val0x6c8,
 541                                        u8 val0x6cc)
 542 {
 543         struct rtl_priv *rtlpriv = btcoexist->adapter;
 544
 545         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 546                  "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6cc = 0x%x\n",
 547                  (force_exec ? "force to" : ""),
 548                  val0x6c0, val0x6c4, val0x6cc);
 549         coex_dm->cur_val0x6c0 = val0x6c0;
 550         coex_dm->cur_val0x6c4 = val0x6c4;
 551         coex_dm->cur_val0x6c8 = val0x6c8;
 552         coex_dm->cur_val0x6cc = val0x6cc;
 553
 554         if (!force_exec) {
 555                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
 556                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
 557                     (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
 558                     (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
 559                         return;
 560         }
 561         halbtc8723b1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
 562                                        val0x6c8, val0x6cc);
 563
 564         coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
 565         coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
 566         coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
 567         coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
 568 }
 569
 570 static void halbtc8723b1ant_coex_table_with_type(struct btc_coexist *btcoexist,
 571                                                  bool force_exec, u8 type)
 572 {
 573         coex_sta->coex_table_type = type;
 574
 575         switch (type) {
 576         case 0:
 577                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
 578                                            0x55555555, 0xffffff, 0x3);
 579                 break;
 580         case 1:
 581                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
 582                                            0x5a5a5a5a, 0xffffff, 0x3);
 583                 break;
 584         case 2:
 585                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
 586                                            0x5a5a5a5a, 0xffffff, 0x3);
 587                 break;
 588         case 3:
 589                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
 590                                            0x5a5a5a5a, 0xffffff, 0x3);
 591                 break;
 592         case 4:
 593                 if ((coex_sta->cck_ever_lock) && (coex_sta->scan_ap_num <= 5))
 594                         halbtc8723b1ant_coex_table(btcoexist, force_exec,
 595                                                    0x55555555, 0xaaaa5a5a,
 596                                                    0xffffff, 0x3);
 597                 else
 598                         halbtc8723b1ant_coex_table(btcoexist, force_exec,
 599                                                    0x55555555, 0x5a5a5a5a,
 600                                                    0xffffff, 0x3);
 601                 break;
 602         case 5:
 603                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
 604                                            0x5aaa5a5a, 0xffffff, 0x3);
 605                 break;
 606         case 6:
 607                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
 608                                            0xaaaaaaaa, 0xffffff, 0x3);
 609                 break;
 610         case 7:
 611                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
 612                                            0xaaaaaaaa, 0xffffff, 0x3);
 613                 break;
 614         case 8:
 615                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 616                                            0x5ada5ada, 0xffffff, 0x3);
 617                 break;
 618         case 9:
 619                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 620                                            0x5ada5ada, 0xffffff, 0x3);
 621                 break;
 622         case 10:
 623                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 624                                            0x5ada5ada, 0xffffff, 0x3);
 625                 break;
 626         case 11:
 627                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 628                                            0x5ada5ada, 0xffffff, 0x3);
 629                 break;
 630         case 12:
 631                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 632                                            0x5ada5ada, 0xffffff, 0x3);
 633                 break;
 634         case 13:
 635                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
 636                                            0xaaaaaaaa, 0xffffff, 0x3);
 637                 break;
 638         case 14:
 639                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
 640                                            0x5ada5ada, 0xffffff, 0x3);
 641                 break;
 642         case 15:
 643                 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
 644                                            0xaaaaaaaa, 0xffffff, 0x3);
 645                 break;
 646         default:
 647                 break;
 648         }
 649 }
 650
 651 static void
 652 halbtc8723b1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
 653                                        bool enable)
 654 {
 655         struct rtl_priv *rtlpriv = btcoexist->adapter;
 656         u8 h2c_parameter[1] = {0};
 657
 658         if (enable)
 659                 h2c_parameter[0] |= BIT0;       /* function enable */
 660
 661         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 662                  "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
 663                  h2c_parameter[0]);
 664
 665         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
 666 }
 667
 668 static void halbtc8723b1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
 669                                             bool force_exec, bool enable)
 670 {
 671         struct rtl_priv *rtlpriv = btcoexist->adapter;
 672
 673         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 674                  "[BTCoex], %s turn Ignore WlanAct %s\n",
 675                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
 676         coex_dm->cur_ignore_wlan_act = enable;
 677
 678         if (!force_exec) {
 679                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 680                          "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
 681                          coex_dm->pre_ignore_wlan_act,
 682                          coex_dm->cur_ignore_wlan_act);
 683
 684                 if (coex_dm->pre_ignore_wlan_act ==
 685                     coex_dm->cur_ignore_wlan_act)
 686                         return;
 687         }
 688         halbtc8723b1ant_set_fw_ignore_wlan_act(btcoexist, enable);
 689
 690         coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
 691 }
 692
 693 static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist,
 694                                            u8 byte1, u8 byte2, u8 byte3,
 695                                            u8 byte4, u8 byte5)
 696 {
 697         struct rtl_priv *rtlpriv = btcoexist->adapter;
 698         u8 h2c_parameter[5] = {0};
 699         u8 real_byte1 = byte1, real_byte5 = byte5;
 700         bool ap_enable = false;
 701
 702         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
 703                            &ap_enable);
 704
 705         if (ap_enable) {
 706                 if ((byte1 & BIT4) && !(byte1 & BIT5)) {
 707                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 708                                  "[BTCoex], FW for 1Ant AP mode\n");
 709                         real_byte1 &= ~BIT4;
 710                         real_byte1 |= BIT5;
 711
 712                         real_byte5 |= BIT5;
 713                         real_byte5 &= ~BIT6;
 714                 }
 715         }
 716
 717         h2c_parameter[0] = real_byte1;
 718         h2c_parameter[1] = byte2;
 719         h2c_parameter[2] = byte3;
 720         h2c_parameter[3] = byte4;
 721         h2c_parameter[4] = real_byte5;
 722
 723         coex_dm->ps_tdma_para[0] = real_byte1;
 724         coex_dm->ps_tdma_para[1] = byte2;
 725         coex_dm->ps_tdma_para[2] = byte3;
 726         coex_dm->ps_tdma_para[3] = byte4;
 727         coex_dm->ps_tdma_para[4] = real_byte5;
 728
 729         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 730                  "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
 731                     h2c_parameter[0],
 732                     h2c_parameter[1] << 24 |
 733                     h2c_parameter[2] << 16 |
 734                     h2c_parameter[3] << 8 |
 735                     h2c_parameter[4]);
 736
 737         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 738 }
 739
 740 static void halbtc8723b1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
 741                                          u8 lps_val, u8 rpwm_val)
 742 {
 743         u8 lps = lps_val;
 744         u8 rpwm = rpwm_val;
 745
 746         btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
 747         btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
 748 }
 749
 750 static void halbtc8723b1ant_lps_rpwm(struct btc_coexist *btcoexist,
 751                                      bool force_exec,
 752                                      u8 lps_val, u8 rpwm_val)
 753 {
 754         struct rtl_priv *rtlpriv = btcoexist->adapter;
 755
 756         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 757                  "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
 758                  (force_exec ? "force to" : ""), lps_val, rpwm_val);
 759         coex_dm->cur_lps = lps_val;
 760         coex_dm->cur_rpwm = rpwm_val;
 761
 762         if (!force_exec) {
 763                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 764                          "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n",
 765                          coex_dm->cur_lps, coex_dm->cur_rpwm);
 766
 767                 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
 768                     (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
 769                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 770                                  "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n",
 771                                  coex_dm->pre_rpwm, coex_dm->cur_rpwm);
 772
 773                         return;
 774                 }
 775         }
 776         halbtc8723b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
 777
 778         coex_dm->pre_lps = coex_dm->cur_lps;
 779         coex_dm->pre_rpwm = coex_dm->cur_rpwm;
 780 }
 781
 782 static void halbtc8723b1ant_sw_mechanism(struct btc_coexist *btcoexist,
 783                                          bool low_penalty_ra)
 784 {
 785         struct rtl_priv *rtlpriv = btcoexist->adapter;
 786
 787         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 788                  "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
 789
 790         halbtc8723b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
 791 }
 792
 793 static void halbtc8723b1ant_set_ant_path(struct btc_coexist *btcoexist,
 794                                          u8 ant_pos_type, bool force_exec,
 795                                          bool init_hw_cfg, bool wifi_off)
 796 {
 797         struct rtl_priv *rtlpriv = btcoexist->adapter;
 798         struct btc_board_info *board_info = &btcoexist->board_info;
 799         u32 fw_ver = 0, u32tmp = 0, cnt_bt_cal_chk = 0;
 800         bool pg_ext_switch = false;
 801         bool use_ext_switch = false;
 802         bool is_in_mp_mode = false;
 803         u8 h2c_parameter[2] = {0}, u8tmp = 0;
 804
 805         coex_dm->cur_ant_pos_type = ant_pos_type;
 806
 807         btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
 808         /* [31:16] = fw ver, [15:0] = fw sub ver */
 809         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
 810
 811         if ((fw_ver < 0xc0000) || pg_ext_switch)
 812                 use_ext_switch = true;
 813
 814         if (init_hw_cfg) {
 815                 /* WiFi TRx Mask on */
 816                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
 817                                           0x780);
 818                 /* remove due to interrupt is disabled that polling c2h will
 819                  * fail and delay 100ms.
 820                  */
 821
 822                 if (fw_ver >= 0x180000) {
 823                         /* Use H2C to set GNT_BT to HIGH */
 824                         h2c_parameter[0] = 1;
 825                         btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
 826                                                 h2c_parameter);
 827                 } else {
 828                         /* set grant_bt to high */
 829                         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
 830                 }
 831                 /* set wlan_act control by PTA */
 832                 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
 833
 834                 /* BT select s0/s1 is controlled by BT */
 835                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
 836                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
 837                 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
 838                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
 839                 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
 840         } else if (wifi_off) {
 841                 if (fw_ver >= 0x180000) {
 842                         /* Use H2C to set GNT_BT to HIGH */
 843                         h2c_parameter[0] = 1;
 844                         btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
 845                                                 h2c_parameter);
 846                 } else {
 847                         /* set grant_bt to high */
 848                         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
 849                 }
 850                 /* set wlan_act to always low */
 851                 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
 852
 853                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
 854                                    &is_in_mp_mode);
 855                 if (!is_in_mp_mode)
 856                         /* BT select s0/s1 is controlled by BT */
 857                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
 858                                                            0x20, 0x0);
 859                 else
 860                         /* BT select s0/s1 is controlled by WiFi */
 861                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
 862                                                            0x20, 0x1);
 863
 864                 /* 0x4c[24:23]=00, Set Antenna control by BT_RFE_CTRL
 865                  * BT Vendor 0xac=0xf002
 866                  */
 867                 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
 868                 u32tmp &= ~BIT23;
 869                 u32tmp &= ~BIT24;
 870                 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
 871         } else {
 872                 /* Use H2C to set GNT_BT to LOW */
 873                 if (fw_ver >= 0x180000) {
 874                         if (btcoexist->btc_read_1byte(btcoexist, 0x765) != 0) {
 875                                 h2c_parameter[0] = 0;
 876                                 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
 877                                                         h2c_parameter);
 878                         }
 879                 } else {
 880                         /* BT calibration check */
 881                         while (cnt_bt_cal_chk <= 20) {
 882                                 u8tmp = btcoexist->btc_read_1byte(btcoexist,
 883                                                                   0x49d);
 884                                 cnt_bt_cal_chk++;
 885                                 if (u8tmp & BIT(0)) {
 886                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 887                                                  DBG_LOUD,
 888                                                  "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
 889                                                  cnt_bt_cal_chk);
 890                                         mdelay(50);
 891                                 } else {
 892                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 893                                                  DBG_LOUD,
 894                                                  "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
 895                                                  cnt_bt_cal_chk);
 896                                         break;
 897                                 }
 898                         }
 899
 900                         /* set grant_bt to PTA */
 901                         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
 902                 }
 903
 904                 if (btcoexist->btc_read_1byte(btcoexist, 0x76e) != 0xc) {
 905                         /* set wlan_act control by PTA */
 906                         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 907                 }
 908
 909                 btcoexist->btc_write_1byte_bitmask(
 910                         btcoexist, 0x67, 0x20,
 911                         0x1); /* BT select s0/s1 is controlled by WiFi */
 912         }
 913
 914         if (use_ext_switch) {
 915                 if (init_hw_cfg) {
 916                         /* 0x4c[23] = 0, 0x4c[24] = 1
 917                          * Antenna control by WL/BT
 918                          */
 919                         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
 920                         u32tmp &= ~BIT23;
 921                         u32tmp |= BIT24;
 922                         btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
 923
 924                         /* fixed internal switch S1->WiFi, S0->BT */
 925                         btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
 926
 927                         if (board_info->btdm_ant_pos ==
 928                             BTC_ANTENNA_AT_MAIN_PORT) {
 929                                 /* tell firmware "no antenna inverse" */
 930                                 h2c_parameter[0] = 0;
 931                                 /* ext switch type */
 932                                 h2c_parameter[1] = 1;
 933                                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
 934                                                         h2c_parameter);
 935                         } else {
 936                                 /* tell firmware "antenna inverse" */
 937                                 h2c_parameter[0] = 1;
 938                                 /* ext switch type */
 939                                 h2c_parameter[1] = 1;
 940                                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
 941                                                         h2c_parameter);
 942                         }
 943                 }
 944
 945                 if (force_exec ||
 946                     (coex_dm->cur_ant_pos_type != coex_dm->pre_ant_pos_type)) {
 947                         /* ext switch setting */
 948                         switch (ant_pos_type) {
 949                         case BTC_ANT_PATH_WIFI:
 950                                 if (board_info->btdm_ant_pos ==
 951                                     BTC_ANTENNA_AT_MAIN_PORT)
 952                                         btcoexist->btc_write_1byte_bitmask(
 953                                                 btcoexist, 0x92c, 0x3, 0x1);
 954                                 else
 955                                         btcoexist->btc_write_1byte_bitmask(
 956                                                 btcoexist, 0x92c, 0x3, 0x2);
 957                                 break;
 958                         case BTC_ANT_PATH_BT:
 959                                 if (board_info->btdm_ant_pos ==
 960                                     BTC_ANTENNA_AT_MAIN_PORT)
 961                                         btcoexist->btc_write_1byte_bitmask(
 962                                                 btcoexist, 0x92c, 0x3, 0x2);
 963                                 else
 964                                         btcoexist->btc_write_1byte_bitmask(
 965                                                 btcoexist, 0x92c, 0x3, 0x1);
 966                                 break;
 967                         default:
 968                         case BTC_ANT_PATH_PTA:
 969                                 if (board_info->btdm_ant_pos ==
 970                                     BTC_ANTENNA_AT_MAIN_PORT)
 971                                         btcoexist->btc_write_1byte_bitmask(
 972                                                 btcoexist, 0x92c, 0x3, 0x1);
 973                                 else
 974                                         btcoexist->btc_write_1byte_bitmask(
 975                                                 btcoexist, 0x92c, 0x3, 0x2);
 976                                 break;
 977                         }
 978                 }
 979         } else {
 980                 if (init_hw_cfg) {
 981                         /* 0x4c[23] = 1, 0x4c[24] = 0,
 982                          * Antenna control by 0x64
 983                          */
 984                         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
 985                         u32tmp |= BIT23;
 986                         u32tmp &= ~BIT24;
 987                         btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
 988
 989                         /* Fix Ext switch Main->S1, Aux->S0 */
 990                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
 991                                                            0x0);
 992
 993                         if (board_info->btdm_ant_pos ==
 994                             BTC_ANTENNA_AT_MAIN_PORT) {
 995                                 /* tell firmware "no antenna inverse" */
 996                                 h2c_parameter[0] = 0;
 997                                 /* internal switch type */
 998                                 h2c_parameter[1] = 0;
 999                                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1000                                                         h2c_parameter);
1001                         } else {
1002                                 /* tell firmware "antenna inverse" */
1003                                 h2c_parameter[0] = 1;
1004                                 /* internal switch type */
1005                                 h2c_parameter[1] = 0;
1006                                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1007                                                         h2c_parameter);
1008                         }
1009                 }
1010
1011                 if (force_exec ||
1012                     (coex_dm->cur_ant_pos_type != coex_dm->pre_ant_pos_type)) {
1013                         /* internal switch setting */
1014                         switch (ant_pos_type) {
1015                         case BTC_ANT_PATH_WIFI:
1016                                 if (board_info->btdm_ant_pos ==
1017                                     BTC_ANTENNA_AT_MAIN_PORT)
1018                                         btcoexist->btc_write_4byte(btcoexist,
1019                                                         0x948, 0x0);
1020                                 else
1021                                         btcoexist->btc_write_4byte(btcoexist,
1022                                                         0x948, 0x280);
1023                                 break;
1024                         case BTC_ANT_PATH_BT:
1025                                 if (board_info->btdm_ant_pos ==
1026                                     BTC_ANTENNA_AT_MAIN_PORT)
1027                                         btcoexist->btc_write_4byte(btcoexist,
1028                                                         0x948, 0x280);
1029                                 else
1030                                         btcoexist->btc_write_4byte(btcoexist,
1031                                                         0x948, 0x0);
1032                                 break;
1033                         default:
1034                         case BTC_ANT_PATH_PTA:
1035                                 if (board_info->btdm_ant_pos ==
1036                                     BTC_ANTENNA_AT_MAIN_PORT)
1037                                         btcoexist->btc_write_4byte(btcoexist,
1038                                                         0x948, 0x200);
1039                                 else
1040                                         btcoexist->btc_write_4byte(btcoexist,
1041                                                         0x948, 0x80);
1042                                 break;
1043                         }
1044                 }
1045         }
1046
1047         coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
1048 }
1049
1050 static void halbtc8723b1ant_ps_tdma(struct btc_coexist *btcoexist,
1051                                     bool force_exec, bool turn_on, u8 type)
1052 {
1053         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1054         bool wifi_busy = false;
1055         u8 rssi_adjust_val = 0;
1056         u8 ps_tdma_byte0_val = 0x51;
1057         u8 ps_tdma_byte3_val = 0x10;
1058         u8 ps_tdma_byte4_val = 0x50;
1059         s8 wifi_duration_adjust = 0x0;
1060         static bool pre_wifi_busy;
1061
1062         coex_dm->cur_ps_tdma_on = turn_on;
1063         coex_dm->cur_ps_tdma = type;
1064
1065         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1066
1067         if (wifi_busy != pre_wifi_busy) {
1068                 force_exec = true;
1069                 pre_wifi_busy = wifi_busy;
1070         }
1071
1072         if (!force_exec) {
1073                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1074                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1075                         return;
1076         }
1077
1078         if (coex_sta->scan_ap_num <= 5) {
1079                 wifi_duration_adjust = 5;
1080
1081                 if (coex_sta->a2dp_bit_pool >= 35)
1082                         wifi_duration_adjust = -10;
1083                 else if (coex_sta->a2dp_bit_pool >= 45)
1084                         wifi_duration_adjust = -15;
1085         } else if (coex_sta->scan_ap_num >= 40) {
1086                 wifi_duration_adjust = -15;
1087
1088                 if (coex_sta->a2dp_bit_pool < 35)
1089                         wifi_duration_adjust = -5;
1090                 else if (coex_sta->a2dp_bit_pool < 45)
1091                         wifi_duration_adjust = -10;
1092         } else if (coex_sta->scan_ap_num >= 20) {
1093                 wifi_duration_adjust = -10;
1094
1095                 if (coex_sta->a2dp_bit_pool >= 45)
1096                         wifi_duration_adjust = -15;
1097         } else {
1098                 wifi_duration_adjust = 0;
1099
1100                 if (coex_sta->a2dp_bit_pool >= 35)
1101                         wifi_duration_adjust = -10;
1102                 else if (coex_sta->a2dp_bit_pool >= 45)
1103                         wifi_duration_adjust = -15;
1104         }
1105
1106         if ((type == 1) || (type == 2) || (type == 9) || (type == 11) ||
1107             (type == 101) || (type == 102) || (type == 109) || (type == 101)) {
1108                 if (!coex_sta->force_lps_on) {
1109                         /* Native power save TDMA, only for A2DP-only case
1110                          * 1/2/9/11 while wifi noisy threshold > 30
1111                          */
1112
1113                         /* no null-pkt */
1114                         ps_tdma_byte0_val = 0x61;
1115                         /* no tx-pause at BT-slot */
1116                         ps_tdma_byte3_val = 0x11;
1117                         /* 0x778 = d/1 toggle, no dynamic slot */
1118                         ps_tdma_byte4_val = 0x10;
1119                 } else {
1120                         /* null-pkt */
1121                         ps_tdma_byte0_val = 0x51;
1122                         /* tx-pause at BT-slot */
1123                         ps_tdma_byte3_val = 0x10;
1124                         /* 0x778 = d/1 toggle, dynamic slot */
1125                         ps_tdma_byte4_val = 0x50;
1126                 }
1127         } else if ((type == 3) || (type == 13) || (type == 14) ||
1128                    (type == 103) || (type == 113) || (type == 114)) {
1129                 /* null-pkt */
1130                 ps_tdma_byte0_val = 0x51;
1131                 /* tx-pause at BT-slot */
1132                 ps_tdma_byte3_val = 0x10;
1133                 /* 0x778 = d/1 toggle, no dynamic slot */
1134                 ps_tdma_byte4_val = 0x10;
1135         } else { /* native power save case */
1136                 /* no null-pkt */
1137                 ps_tdma_byte0_val = 0x61;
1138                 /* no tx-pause at BT-slot */
1139                 ps_tdma_byte3_val = 0x11;
1140                 /* 0x778 = d/1 toggle, no dynamic slot */
1141                 ps_tdma_byte4_val = 0x11;
1142                 /* psTdmaByte4Va is not define for 0x778 = d/1, 1/1 case */
1143         }
1144
1145         /* if (bt_link_info->slave_role) */
1146         if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1147                 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1148                 ps_tdma_byte4_val = ps_tdma_byte4_val | 0x1;
1149
1150         if (type > 100) {
1151                 /* set antenna control by SW     */
1152                 ps_tdma_byte0_val = ps_tdma_byte0_val | 0x82;
1153                 /* set antenna no toggle, control by antenna diversity */
1154                 ps_tdma_byte3_val = ps_tdma_byte3_val | 0x60;
1155         }
1156
1157         if (turn_on) {
1158                 switch (type) {
1159                 default:
1160                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1a,
1161                                                       0x1a, 0x0,
1162                                                       ps_tdma_byte4_val);
1163                         break;
1164                 case 1:
1165                         halbtc8723b1ant_set_fw_ps_tdma(
1166                                 btcoexist, ps_tdma_byte0_val,
1167                                 0x3a + wifi_duration_adjust, 0x03,
1168                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1169
1170                         rssi_adjust_val = 11;
1171                         break;
1172                 case 2:
1173                         halbtc8723b1ant_set_fw_ps_tdma(
1174                                 btcoexist, ps_tdma_byte0_val,
1175                                 0x2d + wifi_duration_adjust, 0x03,
1176                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1177                         break;
1178                 case 3:
1179                         halbtc8723b1ant_set_fw_ps_tdma(
1180                                 btcoexist, ps_tdma_byte0_val, 0x30, 0x03,
1181                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1182                         break;
1183                 case 4:
1184                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1185                                                       0x3, 0x14, 0x0);
1186                         break;
1187                 case 5:
1188                         halbtc8723b1ant_set_fw_ps_tdma(
1189                                 btcoexist, ps_tdma_byte0_val, 0x1f, 0x3,
1190                                 ps_tdma_byte3_val, 0x11);
1191                         break;
1192                 case 6:
1193                         halbtc8723b1ant_set_fw_ps_tdma(
1194                                 btcoexist, ps_tdma_byte0_val, 0x20, 0x3,
1195                                 ps_tdma_byte3_val, 0x11);
1196                         break;
1197                 case 7:
1198                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xc,
1199                                                        0x5, 0x0, 0x0);
1200                         break;
1201                 case 8:
1202                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1203                                                       0x3, 0x10, 0x0);
1204                         break;
1205                 case 9:
1206                         halbtc8723b1ant_set_fw_ps_tdma(
1207                                 btcoexist, ps_tdma_byte0_val, 0x21, 0x3,
1208                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1209                         break;
1210                 case 10:
1211                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1212                                                        0xa, 0x0, 0x40);
1213                         break;
1214                 case 11:
1215                         halbtc8723b1ant_set_fw_ps_tdma(
1216                                 btcoexist, ps_tdma_byte0_val, 0x21, 0x03,
1217                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1218                         break;
1219                 case 12:
1220                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x0a,
1221                                                       0x0a, 0x0, 0x50);
1222                         break;
1223                 case 13:
1224                         if (coex_sta->scan_ap_num <= 3)
1225                                 halbtc8723b1ant_set_fw_ps_tdma(
1226                                         btcoexist, ps_tdma_byte0_val, 0x40, 0x3,
1227                                         ps_tdma_byte3_val, ps_tdma_byte4_val);
1228                         else
1229                                 halbtc8723b1ant_set_fw_ps_tdma(
1230                                         btcoexist, ps_tdma_byte0_val, 0x21, 0x3,
1231                                         ps_tdma_byte3_val, ps_tdma_byte4_val);
1232                         break;
1233                 case 14:
1234                         if (coex_sta->scan_ap_num <= 3)
1235                                 halbtc8723b1ant_set_fw_ps_tdma(
1236                                         btcoexist, 0x51, 0x30, 0x3, 0x10, 0x50);
1237                         else
1238                                 halbtc8723b1ant_set_fw_ps_tdma(
1239                                         btcoexist, ps_tdma_byte0_val, 0x21, 0x3,
1240                                         ps_tdma_byte3_val, ps_tdma_byte4_val);
1241                         break;
1242                 case 15:
1243                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1244                                                        0x3, 0x8, 0x0);
1245                         break;
1246                 case 16:
1247                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1248                                                       0x3, 0x10, 0x0);
1249                         break;
1250                 case 18:
1251                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1252                                                       0x3, 0x10, 0x0);
1253                         break;
1254                 case 20:
1255                         halbtc8723b1ant_set_fw_ps_tdma(
1256                                 btcoexist, ps_tdma_byte0_val, 0x3f, 0x03,
1257                                 ps_tdma_byte3_val, 0x10);
1258                         break;
1259                 case 21:
1260                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1261                                                       0x03, 0x11, 0x11);
1262                         break;
1263                 case 22:
1264                         halbtc8723b1ant_set_fw_ps_tdma(
1265                                 btcoexist, ps_tdma_byte0_val, 0x25, 0x03,
1266                                 ps_tdma_byte3_val, 0x10);
1267                         break;
1268                 case 23:
1269                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1270                                                       0x3, 0x31, 0x18);
1271                         break;
1272                 case 24:
1273                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1274                                                       0x3, 0x31, 0x18);
1275                         break;
1276                 case 25:
1277                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1278                                                        0x3, 0x31, 0x18);
1279                         break;
1280                 case 26:
1281                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1282                                                        0x3, 0x31, 0x18);
1283                         break;
1284                 case 27:
1285                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1286                                                       0x3, 0x31, 0x98);
1287                         break;
1288                 case 28:
1289                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x69, 0x25,
1290                                                       0x3, 0x31, 0x0);
1291                         break;
1292                 case 29:
1293                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xab, 0x1a,
1294                                                       0x1a, 0x1, 0x10);
1295                         break;
1296                 case 30:
1297                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1298                                                        0x3, 0x10, 0x10);
1299                         break;
1300                 case 31:
1301                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1a,
1302                                                       0x1a, 0, 0x58);
1303                         break;
1304                 case 32:
1305                         halbtc8723b1ant_set_fw_ps_tdma(
1306                                 btcoexist, ps_tdma_byte0_val, 0x35, 0x3,
1307                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1308                         break;
1309                 case 33:
1310                         halbtc8723b1ant_set_fw_ps_tdma(
1311                                 btcoexist, ps_tdma_byte0_val, 0x35, 0x3,
1312                                 ps_tdma_byte3_val, 0x10);
1313                         break;
1314                 case 34:
1315                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x53, 0x1a,
1316                                                       0x1a, 0x0, 0x10);
1317                         break;
1318                 case 35:
1319                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x63, 0x1a,
1320                                                       0x1a, 0x0, 0x10);
1321                         break;
1322                 case 36:
1323                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x12,
1324                                                       0x3, 0x14, 0x50);
1325                         break;
1326                 case 40:
1327                         /* SoftAP only with no sta associated,BT disable ,TDMA
1328                          * mode for power saving
1329                          *
1330                          * here softap mode screen off will cost 70-80mA for
1331                          * phone
1332                          */
1333                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x23, 0x18,
1334                                                       0x00, 0x10, 0x24);
1335                         break;
1336
1337                 case 101:
1338                         /* for 1-Ant translate to 2-Ant  */
1339                         halbtc8723b1ant_set_fw_ps_tdma(
1340                                 btcoexist, ps_tdma_byte0_val,
1341                                 0x3a + wifi_duration_adjust, 0x03,
1342                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1343                         break;
1344                 case 102:
1345                         halbtc8723b1ant_set_fw_ps_tdma(
1346                                 btcoexist, ps_tdma_byte0_val,
1347                                 0x2d + wifi_duration_adjust, 0x03,
1348                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1349                         break;
1350                 case 103:
1351                         halbtc8723b1ant_set_fw_ps_tdma(
1352                                 btcoexist, ps_tdma_byte0_val, 0x3a, 0x03,
1353                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1354                         break;
1355                 case 105:
1356                         halbtc8723b1ant_set_fw_ps_tdma(
1357                                 btcoexist, ps_tdma_byte0_val, 0x15, 0x3,
1358                                 ps_tdma_byte3_val, 0x11);
1359                         break;
1360                 case 106:
1361                         halbtc8723b1ant_set_fw_ps_tdma(
1362                                 btcoexist, ps_tdma_byte0_val, 0x20, 0x3,
1363                                 ps_tdma_byte3_val, 0x11);
1364                         break;
1365                 case 109:
1366                         halbtc8723b1ant_set_fw_ps_tdma(
1367                                 btcoexist, ps_tdma_byte0_val, 0x21, 0x3,
1368                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1369                         break;
1370                 case 111:
1371                         halbtc8723b1ant_set_fw_ps_tdma(
1372                                 btcoexist, ps_tdma_byte0_val, 0x21, 0x03,
1373                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1374                         break;
1375                 case 113:
1376                         halbtc8723b1ant_set_fw_ps_tdma(
1377                                 btcoexist, ps_tdma_byte0_val, 0x21, 0x3,
1378                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1379                         break;
1380                 case 114:
1381                         halbtc8723b1ant_set_fw_ps_tdma(
1382                                 btcoexist, ps_tdma_byte0_val, 0x21, 0x3,
1383                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1384                         break;
1385                 case 120:
1386                         halbtc8723b1ant_set_fw_ps_tdma(
1387                                 btcoexist, ps_tdma_byte0_val, 0x3f, 0x03,
1388                                 ps_tdma_byte3_val, 0x10);
1389                         break;
1390                 case 122:
1391                         halbtc8723b1ant_set_fw_ps_tdma(
1392                                 btcoexist, ps_tdma_byte0_val, 0x25, 0x03,
1393                                 ps_tdma_byte3_val, 0x10);
1394                         break;
1395                 case 132:
1396                         halbtc8723b1ant_set_fw_ps_tdma(
1397                                 btcoexist, ps_tdma_byte0_val, 0x25, 0x03,
1398                                 ps_tdma_byte3_val, ps_tdma_byte4_val);
1399                         break;
1400                 case 133:
1401                         halbtc8723b1ant_set_fw_ps_tdma(
1402                                 btcoexist, ps_tdma_byte0_val, 0x25, 0x03,
1403                                 ps_tdma_byte3_val, 0x11);
1404                         break;
1405                 }
1406         } else {
1407                 /* disable PS tdma */
1408                 switch (type) {
1409                 case 8: /* PTA Control */
1410                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x8, 0x0,
1411                                                        0x0, 0x0, 0x0);
1412                         halbtc8723b1ant_set_ant_path(btcoexist,
1413                                                      BTC_ANT_PATH_PTA,
1414                                                      FORCE_EXEC,
1415                                                      false, false);
1416                         break;
1417                 case 0:
1418                 default:
1419                         /* Software control, Antenna at BT side */
1420                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0,
1421                                                        0x0, 0x0, 0x0);
1422                         break;
1423                 case 1: /* 2-Ant, 0x778=3, antenna control by ant diversity */
1424                         halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1425                                                        0x48, 0x0);
1426                         break;
1427                 }
1428         }
1429         rssi_adjust_val = 0;
1430         btcoexist->btc_set(btcoexist,
1431                            BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE,
1432                            &rssi_adjust_val);
1433
1434         /* update pre state */
1435         coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1436         coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1437 }
1438
1439 void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
1440                                        u8 wifi_status)
1441 {
1442         struct rtl_priv *rtlpriv = btcoexist->adapter;
1443         static s32 up, dn, m, n, wait_count;
1444         /*  0: no change, +1: increase WiFi duration,
1445          * -1: decrease WiFi duration
1446          */
1447         s32 result;
1448         u8 retry_count = 0, bt_info_ext;
1449         bool wifi_busy = false;
1450
1451         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1452                  "[BTCoex], TdmaDurationAdjustForAcl()\n");
1453
1454         if (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY)
1455                 wifi_busy = true;
1456         else
1457                 wifi_busy = false;
1458
1459         if ((wifi_status ==
1460              BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN) ||
1461             (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN) ||
1462             (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT)) {
1463                 if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 &&
1464                     coex_dm->cur_ps_tdma != 3 && coex_dm->cur_ps_tdma != 9) {
1465                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1466                                                 true, 9);
1467                         coex_dm->ps_tdma_du_adj_type = 9;
1468
1469                         up = 0;
1470                         dn = 0;
1471                         m = 1;
1472                         n = 3;
1473                         result = 0;
1474                         wait_count = 0;
1475                 }
1476                 return;
1477         }
1478
1479         if (!coex_dm->auto_tdma_adjust) {
1480                 coex_dm->auto_tdma_adjust = true;
1481                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1482                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
1483
1484                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1485                 coex_dm->ps_tdma_du_adj_type = 2;
1486
1487                 up = 0;
1488                 dn = 0;
1489                 m = 1;
1490                 n = 3;
1491                 result = 0;
1492                 wait_count = 0;
1493         } else {
1494                 /* acquire the BT TRx retry count from BT_Info byte2 */
1495                 retry_count = coex_sta->bt_retry_cnt;
1496                 bt_info_ext = coex_sta->bt_info_ext;
1497
1498                 if ((coex_sta->low_priority_tx) > 1050 ||
1499                     (coex_sta->low_priority_rx) > 1250)
1500                         retry_count++;
1501
1502                 result = 0;
1503                 wait_count++;
1504                 /* no retry in the last 2-second duration */
1505                 if (retry_count == 0) {
1506                         up++;
1507                         dn--;
1508
1509                         if (dn <= 0)
1510                                 dn = 0;
1511
1512                         if (up >= n) {
1513                                 /* if retry count during continuous n*2 seconds
1514                                  * is 0, enlarge WiFi duration
1515                                  */
1516                                 wait_count = 0;
1517                                 n = 3;
1518                                 up = 0;
1519                                 dn = 0;
1520                                 result = 1;
1521                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1522                                          "[BTCoex], Increase wifi duration!!\n");
1523                         }
1524                 } else if (retry_count <= 3) {
1525                         /* <=3 retry in the last 2-second duration */
1526                         up--;
1527                         dn++;
1528
1529                         if (up <= 0)
1530                                 up = 0;
1531
1532                         if (dn == 2) {
1533                                 /* if continuous 2 retry count(every 2 seconds)
1534                                  * >0 and < 3, reduce WiFi duration
1535                                  */
1536                                 if (wait_count <= 2)
1537                                         /* avoid loop between the two levels */
1538                                         m++;
1539                                 else
1540                                         m = 1;
1541
1542                                 if (m >= 20)
1543                                         /* maximum of m = 20 ' will recheck if
1544                                          * need to adjust wifi duration in
1545                                          * maximum time interval 120 seconds
1546                                          */
1547                                         m = 20;
1548
1549                                 n = 3 * m;
1550                                 up = 0;
1551                                 dn = 0;
1552                                 wait_count = 0;
1553                                 result = -1;
1554                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1555                                          "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1556                         }
1557                 } else {
1558                         /* retry count > 3, once retry count > 3, to reduce
1559                          * WiFi duration
1560                          */
1561                         if (wait_count == 1)
1562                                 /* to avoid loop between the two levels */
1563                                 m++;
1564                         else
1565                                 m = 1;
1566
1567                         if (m >= 20)
1568                                 /* maximum of m = 20 ' will recheck if need to
1569                                  * adjust wifi duration in maximum time interval
1570                                  * 120 seconds
1571                                  */
1572                                 m = 20;
1573
1574                         n = 3 * m;
1575                         up = 0;
1576                         dn = 0;
1577                         wait_count = 0;
1578                         result = -1;
1579                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1580                                  "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1581                 }
1582
1583                 if (result == -1) {
1584                         if (coex_dm->cur_ps_tdma == 1) {
1585                                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1586                                                         true, 2);
1587                                 coex_dm->ps_tdma_du_adj_type = 2;
1588                         } else if (coex_dm->cur_ps_tdma == 2) {
1589                                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1590                                                         true, 9);
1591                                 coex_dm->ps_tdma_du_adj_type = 9;
1592                         } else if (coex_dm->cur_ps_tdma == 9) {
1593                                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1594                                                         true, 11);
1595                                 coex_dm->ps_tdma_du_adj_type = 11;
1596                         }
1597                 } else if (result == 1) {
1598                         if (coex_dm->cur_ps_tdma == 11) {
1599                                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1600                                                         true, 9);
1601                                 coex_dm->ps_tdma_du_adj_type = 9;
1602                         } else if (coex_dm->cur_ps_tdma == 9) {
1603                                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1604                                                         true, 2);
1605                                 coex_dm->ps_tdma_du_adj_type = 2;
1606                         } else if (coex_dm->cur_ps_tdma == 2) {
1607                                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1608                                                         true, 1);
1609                                 coex_dm->ps_tdma_du_adj_type = 1;
1610                         }
1611                 }
1612
1613                 if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 &&
1614                     coex_dm->cur_ps_tdma != 9 && coex_dm->cur_ps_tdma != 11) {
1615                         /* recover to previous adjust type */
1616                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1617                                                 coex_dm->ps_tdma_du_adj_type);
1618                 }
1619         }
1620 }
1621
1622 static void halbtc8723b1ant_ps_tdma_chk_pwr_save(struct btc_coexist *btcoexist,
1623                                           bool new_ps_state)
1624 {
1625         u8 lps_mode = 0x0;
1626
1627         btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1628
1629         if (lps_mode) {
1630                 /* already under LPS state */
1631                 if (new_ps_state) {
1632                         /* keep state under LPS, do nothing. */
1633                 } else {
1634                         /* will leave LPS state, turn off psTdma first */
1635                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1636                                                 false, 0);
1637                 }
1638         } else {
1639                 /* NO PS state */
1640                 if (new_ps_state) {
1641                         /* will enter LPS state, turn off psTdma first */
1642                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1643                                                 false, 0);
1644                 } else {
1645                         /* keep state under NO PS state, do nothing. */
1646                 }
1647         }
1648 }
1649
1650 static void halbtc8723b1ant_power_save_state(struct btc_coexist *btcoexist,
1651                                              u8 ps_type, u8 lps_val,
1652                                              u8 rpwm_val)
1653 {
1654         bool low_pwr_disable = false;
1655
1656         switch (ps_type) {
1657         case BTC_PS_WIFI_NATIVE:
1658                 /* recover to original 32k low power setting */
1659                 low_pwr_disable = false;
1660                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1661                                    &low_pwr_disable);
1662                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1663                 coex_sta->force_lps_on = false;
1664                 break;
1665         case BTC_PS_LPS_ON:
1666                 halbtc8723b1ant_ps_tdma_chk_pwr_save(btcoexist, true);
1667                 halbtc8723b1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1668                                          rpwm_val);
1669                 /* when coex force to enter LPS, do not enter 32k low power */
1670                 low_pwr_disable = true;
1671                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1672                                    &low_pwr_disable);
1673                 /* power save must executed before psTdma */
1674                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1675                 coex_sta->force_lps_on = true;
1676                 break;
1677         case BTC_PS_LPS_OFF:
1678                 halbtc8723b1ant_ps_tdma_chk_pwr_save(btcoexist, false);
1679                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1680                 coex_sta->force_lps_on = false;
1681                 break;
1682         default:
1683                 break;
1684         }
1685 }
1686
1687 static void halbtc8723b1ant_action_wifi_only(struct btc_coexist *btcoexist)
1688 {
1689         halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
1690         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
1691         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1692                                      FORCE_EXEC, false, false);
1693 }
1694
1695 /* check if BT is disabled */
1696 static void halbtc8723b1ant_monitor_bt_enable_disable(struct btc_coexist
1697                                                       *btcoexist)
1698 {
1699         struct rtl_priv *rtlpriv = btcoexist->adapter;
1700         static u32 bt_disable_cnt;
1701         bool bt_active = true, bt_disabled = false;
1702
1703         if (coex_sta->high_priority_tx == 0 &&
1704             coex_sta->high_priority_rx == 0 && coex_sta->low_priority_tx == 0 &&
1705             coex_sta->low_priority_rx == 0)
1706                 bt_active = false;
1707         if (coex_sta->high_priority_tx == 0xffff &&
1708             coex_sta->high_priority_rx == 0xffff &&
1709             coex_sta->low_priority_tx == 0xffff &&
1710             coex_sta->low_priority_rx == 0xffff)
1711                 bt_active = false;
1712         if (bt_active) {
1713                 bt_disable_cnt = 0;
1714                 bt_disabled = false;
1715         } else {
1716                 bt_disable_cnt++;
1717                 if (bt_disable_cnt >= 2)
1718                         bt_disabled = true;
1719         }
1720         if (coex_sta->bt_disabled != bt_disabled) {
1721                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1722                          "[BTCoex], BT is from %s to %s!!\n",
1723                          (coex_sta->bt_disabled ? "disabled" : "enabled"),
1724                          (bt_disabled ? "disabled" : "enabled"));
1725
1726                 coex_sta->bt_disabled = bt_disabled;
1727                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1728                                    &bt_disabled);
1729                 if (bt_disabled) {
1730                         halbtc8723b1ant_action_wifi_only(btcoexist);
1731                         btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1732                                            NULL);
1733                         btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
1734                                            NULL);
1735                 }
1736         }
1737 }
1738
1739 /*****************************************************
1740  *
1741  *      Non-Software Coex Mechanism start
1742  *
1743  *****************************************************/
1744
1745 static void halbtc8723b1ant_action_bt_whck_test(struct btc_coexist *btcoexist)
1746 {
1747         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
1748                                          0x0);
1749
1750         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1751         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
1752                                      false, false);
1753         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1754 }
1755
1756 static void halbtc8723b1ant_action_wifi_multiport(struct btc_coexist *btcoexist)
1757 {
1758         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1759                                          0x0, 0x0);
1760
1761         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1762         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
1763                                      false, false);
1764         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1765 }
1766
1767 static void halbtc8723b1ant_action_hs(struct btc_coexist *btcoexist)
1768 {
1769         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1770         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1771 }
1772
1773 static void halbtc8723b1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1774 {
1775         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1776         bool wifi_connected = false, ap_enable = false;
1777         bool wifi_busy = false, bt_busy = false;
1778
1779         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1780                            &ap_enable);
1781         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1782                            &wifi_connected);
1783         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1784         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1785
1786         if (coex_sta->bt_abnormal_scan) {
1787                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
1788                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1789         } else if (!wifi_connected && !coex_sta->wifi_is_high_pri_task) {
1790                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1791                                                  0x0, 0x0);
1792                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1793                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1794                                              NORMAL_EXEC, false, false);
1795                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1796         } else if (bt_link_info->sco_exist || bt_link_info->hid_exist ||
1797                    bt_link_info->a2dp_exist) {
1798                 /* SCO/HID/A2DP busy */
1799                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1800                                                  0x0, 0x0);
1801                 if (coex_sta->c2h_bt_remote_name_req)
1802                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1803                                                 33);
1804                 else
1805                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1806                                                 32);
1807
1808                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1809         } else if (bt_link_info->pan_exist || wifi_busy) {
1810                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1811                                                  0x0, 0x0);
1812                 if (coex_sta->c2h_bt_remote_name_req)
1813                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1814                                                 33);
1815                 else
1816                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1817                                                 32);
1818
1819                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1820         } else {
1821                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1822                                                  0x0, 0x0);
1823                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1824                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1825                                              NORMAL_EXEC, false, false);
1826                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1827         }
1828 }
1829
1830 static void btc8723b1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
1831                                                   u8 wifi_status)
1832 {
1833         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1834         bool wifi_connected = false;
1835
1836         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1837                            &wifi_connected);
1838
1839         /* tdma and coex table */
1840         if (bt_link_info->sco_exist) {
1841                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1842                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
1843         } else {
1844                 /* HID */
1845                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1846                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
1847         }
1848 }
1849
1850 static void halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
1851                                         struct btc_coexist *btcoexist,
1852                                         u8 wifi_status)
1853 {
1854         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1855
1856         if ((coex_sta->low_priority_rx >= 950) && (!coex_sta->under_ips))
1857                 bt_link_info->slave_role = true;
1858         else
1859                 bt_link_info->slave_role = false;
1860
1861         if (bt_link_info->hid_only) { /* HID */
1862                 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, wifi_status);
1863                 coex_dm->auto_tdma_adjust = false;
1864                 return;
1865         } else if (bt_link_info->a2dp_only) { /* A2DP */
1866                 if (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1867                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1868                                                 true, 32);
1869                         halbtc8723b1ant_coex_table_with_type(btcoexist,
1870                                                              NORMAL_EXEC, 4);
1871                         coex_dm->auto_tdma_adjust = false;
1872                 } else {
1873                         btc8723b1ant_tdma_dur_adj_for_acl(btcoexist,
1874                                                           wifi_status);
1875                         halbtc8723b1ant_coex_table_with_type(btcoexist,
1876                                                              NORMAL_EXEC, 1);
1877                         coex_dm->auto_tdma_adjust = true;
1878                 }
1879         } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
1880                    (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
1881                     bt_link_info->pan_exist)) {
1882                 /* A2DP + PAN(OPP,FTP), HID + A2DP + PAN(OPP,FTP) */
1883                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
1884                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1885                 coex_dm->auto_tdma_adjust = false;
1886         } else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) {
1887                 /* HID + A2DP */
1888                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1889                 coex_dm->auto_tdma_adjust = false;
1890
1891                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1892         } else if (bt_link_info->pan_only ||
1893                         (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
1894                 /* PAN(OPP,FTP), HID + PAN(OPP,FTP) */
1895                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1896                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1897                 coex_dm->auto_tdma_adjust = false;
1898         } else {
1899                 /* BT no-profile busy (0x9) */
1900                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
1901                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1902                 coex_dm->auto_tdma_adjust = false;
1903         }
1904 }
1905
1906 static void btc8723b1ant_action_wifi_not_conn(struct btc_coexist *btcoexist)
1907 {
1908         /* power save state */
1909         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1910                                          0x0, 0x0);
1911
1912         /* tdma and coex table */
1913         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
1914         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
1915                                      false, false);
1916         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1917 }
1918
1919 static void
1920 btc8723b1ant_action_wifi_not_conn_scan(struct btc_coexist *btcoexist)
1921 {
1922         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1923
1924         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1925                                          0x0, 0x0);
1926
1927         /* tdma and coex table */
1928         if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1929                 if (bt_link_info->a2dp_exist) {
1930                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1931                                                 true, 32);
1932                         halbtc8723b1ant_coex_table_with_type(btcoexist,
1933                                                              NORMAL_EXEC, 4);
1934                 } else if (bt_link_info->a2dp_exist) {
1935                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1936                                                 true, 22);
1937                         halbtc8723b1ant_coex_table_with_type(btcoexist,
1938                                                              NORMAL_EXEC, 4);
1939                 } else {
1940                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1941                                                 true, 20);
1942                         halbtc8723b1ant_coex_table_with_type(btcoexist,
1943                                                              NORMAL_EXEC, 1);
1944                 }
1945         } else if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
1946                    coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY){
1947                 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
1948                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1949         } else {
1950                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1951                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1952                                              NORMAL_EXEC, false, false);
1953                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1954         }
1955 }
1956
1957 static void
1958 btc8723b1ant_act_wifi_not_conn_asso_auth(struct btc_coexist *btcoexist)
1959 {
1960         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1961
1962         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1963                                          0x0, 0x0);
1964
1965         /* tdma and coex table */
1966         if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
1967             (bt_link_info->a2dp_exist)) {
1968                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1969                 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
1970         } else if (bt_link_info->pan_exist) {
1971                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1972                 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
1973         } else {
1974                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1975                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1976                                              NORMAL_EXEC, false, false);
1977                 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
1978         }
1979 }
1980
1981 static void btc8723b1ant_action_wifi_conn_scan(struct btc_coexist *btcoexist)
1982 {
1983         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1984
1985         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1986                                          0x0, 0x0);
1987
1988         /* tdma and coex table */
1989         if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1990                 if (bt_link_info->a2dp_exist) {
1991                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1992                                                 true, 32);
1993                         halbtc8723b1ant_coex_table_with_type(btcoexist,
1994                                                              NORMAL_EXEC, 4);
1995                 } else if (bt_link_info->a2dp_exist &&
1996                            bt_link_info->pan_exist) {
1997                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1998                                                 true, 22);
1999                         halbtc8723b1ant_coex_table_with_type(btcoexist,
2000                                                              NORMAL_EXEC, 4);
2001                 } else {
2002                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2003                                                 true, 20);
2004                         halbtc8723b1ant_coex_table_with_type(btcoexist,
2005                                                              NORMAL_EXEC, 4);
2006                 }
2007         } else if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2008                    coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) {
2009                 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
2010                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
2011         } else {
2012                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2013                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2014                                              NORMAL_EXEC, false, false);
2015                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2016         }
2017 }
2018
2019 static void halbtc8723b1ant_action_wifi_connected_special_packet(
2020                                                 struct btc_coexist *btcoexist)
2021 {
2022         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2023         bool wifi_busy = false;
2024
2025         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2026
2027         /* no special packet process for both WiFi and BT very busy */
2028         if ((wifi_busy) &&
2029             ((bt_link_info->pan_exist) || (coex_sta->num_of_profile >= 2)))
2030                 return;
2031
2032         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2033                                          0x0, 0x0);
2034
2035         /* tdma and coex table */
2036         if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
2037                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2038                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2039         } else if (bt_link_info->a2dp_exist) {
2040                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2041                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2042         } else if (bt_link_info->pan_exist) {
2043                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
2044                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2045         } else {
2046                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2047                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2048                                              NORMAL_EXEC, false, false);
2049                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2050         }
2051 }
2052
2053 static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist *btcoexist)
2054 {
2055         struct rtl_priv *rtlpriv = btcoexist->adapter;
2056         bool wifi_busy = false;
2057         bool scan = false, link = false, roam = false;
2058         bool under_4way = false, ap_enable = false;
2059
2060         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2061                  "[BTCoex], CoexForWifiConnect()===>\n");
2062
2063         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
2064                            &under_4way);
2065         if (under_4way) {
2066                 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist);
2067                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2068                          "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
2069                 return;
2070         }
2071
2072         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2073         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2074         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2075
2076         if (scan || link || roam) {
2077                 if (scan)
2078                         btc8723b1ant_action_wifi_conn_scan(btcoexist);
2079                 else
2080                         halbtc8723b1ant_action_wifi_connected_special_packet(
2081                                                                      btcoexist);
2082                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2083                          "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
2084                 return;
2085         }
2086
2087         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
2088                            &ap_enable);
2089         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2090         /* power save state */
2091         if (!ap_enable &&
2092             coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY &&
2093             !btcoexist->bt_link_info.hid_only) {
2094                 if (btcoexist->bt_link_info.a2dp_only) {
2095                         if (!wifi_busy) {
2096                                 halbtc8723b1ant_power_save_state(btcoexist,
2097                                                          BTC_PS_WIFI_NATIVE,
2098                                                          0x0, 0x0);
2099                         } else { /* busy */
2100                                 if (coex_sta->scan_ap_num >=
2101                                     BT_8723B_1ANT_WIFI_NOISY_THRESH)
2102                                         /* no force LPS, no PS-TDMA,
2103                                          * use pure TDMA
2104                                          */
2105                                         halbtc8723b1ant_power_save_state(
2106                                                 btcoexist, BTC_PS_WIFI_NATIVE,
2107                                                 0x0, 0x0);
2108                                 else
2109                                         halbtc8723b1ant_power_save_state(
2110                                                 btcoexist, BTC_PS_LPS_ON, 0x50,
2111                                                 0x4);
2112                         }
2113                 } else if ((!coex_sta->pan_exist) && (!coex_sta->a2dp_exist) &&
2114                            (!coex_sta->hid_exist))
2115                         halbtc8723b1ant_power_save_state(
2116                                 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2117                 else
2118                         halbtc8723b1ant_power_save_state(btcoexist,
2119                                                          BTC_PS_LPS_ON,
2120                                                          0x50, 0x4);
2121         } else {
2122                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2123                                                  0x0, 0x0);
2124         }
2125         /* tdma and coex table */
2126         if (!wifi_busy) {
2127                 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
2128                         halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2129                                 btcoexist,
2130                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
2131                 } else if (coex_dm->bt_status ==
2132                                 BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2133                            coex_dm->bt_status ==
2134                                 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) {
2135                         btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
2136                                      BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
2137                 } else {
2138                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2139                                                 false, 8);
2140                         halbtc8723b1ant_set_ant_path(btcoexist,
2141                                                      BTC_ANT_PATH_PTA,
2142                                                      NORMAL_EXEC, false, false);
2143                         halbtc8723b1ant_coex_table_with_type(btcoexist,
2144                                                              NORMAL_EXEC, 2);
2145                 }
2146         } else {
2147                 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
2148                         halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2149                                 btcoexist,
2150                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
2151                 } else if (coex_dm->bt_status ==
2152                                 BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2153                            coex_dm->bt_status ==
2154                                 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) {
2155                         btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
2156                                     BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
2157                 } else {
2158                         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2159                                                 true, 32);
2160                         halbtc8723b1ant_set_ant_path(btcoexist,
2161                                                      BTC_ANT_PATH_PTA,
2162                                                      NORMAL_EXEC, false, false);
2163                         halbtc8723b1ant_coex_table_with_type(btcoexist,
2164                                                              NORMAL_EXEC, 4);
2165                 }
2166         }
2167 }
2168
2169 static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
2170 {
2171         struct rtl_priv *rtlpriv = btcoexist->adapter;
2172         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2173         bool wifi_connected = false, bt_hs_on = false, wifi_busy = false;
2174         bool increase_scan_dev_num = false;
2175         bool bt_ctrl_agg_buf_size = false;
2176         bool miracast_plus_bt = false;
2177         u8 agg_buf_size = 5;
2178         u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2179         u32 wifi_link_status = 0;
2180         u32 num_of_wifi_link = 0;
2181         u32 wifi_bw;
2182
2183         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2184                  "[BTCoex], RunCoexistMechanism()===>\n");
2185
2186         if (btcoexist->manual_control) {
2187                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2188                          "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
2189                 return;
2190         }
2191
2192         if (btcoexist->stop_coex_dm) {
2193                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2194                          "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
2195                 return;
2196         }
2197
2198         if (coex_sta->under_ips) {
2199                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2200                          "[BTCoex], wifi is under IPS !!!\n");
2201                 return;
2202         }
2203
2204         if (coex_sta->bt_whck_test) {
2205                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2206                          "[BTCoex], wifi is under IPS !!!\n");
2207                 halbtc8723b1ant_action_bt_whck_test(btcoexist);
2208                 return;
2209         }
2210
2211         if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY ||
2212             coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2213             coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
2214                 increase_scan_dev_num = true;
2215
2216         btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
2217                            &increase_scan_dev_num);
2218         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2219                            &wifi_connected);
2220         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2221
2222         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2223                            &wifi_link_status);
2224         num_of_wifi_link = wifi_link_status >> 16;
2225
2226         if (num_of_wifi_link >= 2 ||
2227             wifi_link_status & WIFI_P2P_GO_CONNECTED) {
2228                 if (bt_link_info->bt_link_exist) {
2229                         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1,
2230                                                    0, 1);
2231                         miracast_plus_bt = true;
2232                 } else {
2233                         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0,
2234                                                    0, 0);
2235                         miracast_plus_bt = false;
2236                 }
2237                 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
2238                                    &miracast_plus_bt);
2239                 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2240                                            bt_ctrl_agg_buf_size, agg_buf_size);
2241
2242                 if ((bt_link_info->a2dp_exist || wifi_busy) &&
2243                     (coex_sta->c2h_bt_inquiry_page))
2244                         halbtc8723b1ant_action_bt_inquiry(btcoexist);
2245                 else
2246                         halbtc8723b1ant_action_wifi_multiport(btcoexist);
2247
2248                 return;
2249         }
2250
2251         miracast_plus_bt = false;
2252         btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
2253                            &miracast_plus_bt);
2254         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2255
2256         if (bt_link_info->bt_link_exist && wifi_connected) {
2257                 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 0, 1);
2258
2259                 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2260
2261                 if (iot_peer != BTC_IOT_PEER_CISCO &&
2262                     iot_peer != BTC_IOT_PEER_BROADCOM) {
2263                         if (bt_link_info->sco_exist)
2264                                 halbtc8723b1ant_limited_rx(btcoexist,
2265                                                            NORMAL_EXEC, false,
2266                                                            false, 0x5);
2267                         else
2268                                 halbtc8723b1ant_limited_rx(btcoexist,
2269                                                            NORMAL_EXEC, false,
2270                                                            false, 0x5);
2271                 } else {
2272                         if (bt_link_info->sco_exist) {
2273                                 halbtc8723b1ant_limited_rx(btcoexist,
2274                                                            NORMAL_EXEC, true,
2275                                                            false, 0x5);
2276                         } else {
2277                                 if (wifi_bw == BTC_WIFI_BW_HT40)
2278                                         halbtc8723b1ant_limited_rx(
2279                                                 btcoexist, NORMAL_EXEC, false,
2280                                                 true, 0x10);
2281                                 else
2282                                         halbtc8723b1ant_limited_rx(
2283                                                 btcoexist, NORMAL_EXEC, false,
2284                                                 true, 0x8);
2285                         }
2286                 }
2287
2288                 halbtc8723b1ant_sw_mechanism(btcoexist, true);
2289         } else {
2290                 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2291
2292                 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2293                                            0x5);
2294
2295                 halbtc8723b1ant_sw_mechanism(btcoexist, false);
2296         }
2297         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2298
2299         if (coex_sta->c2h_bt_inquiry_page) {
2300                 halbtc8723b1ant_action_bt_inquiry(btcoexist);
2301                 return;
2302         } else if (bt_hs_on) {
2303                 halbtc8723b1ant_action_hs(btcoexist);
2304                 return;
2305         }
2306
2307         if (!wifi_connected) {
2308                 bool scan = false, link = false, roam = false;
2309
2310                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2311                          "[BTCoex], wifi is non connected-idle !!!\n");
2312
2313                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2314                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2315                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2316
2317                 if (scan || link || roam) {
2318                         if (scan)
2319                                 btc8723b1ant_action_wifi_not_conn_scan(
2320                                                                      btcoexist);
2321                         else
2322                                 btc8723b1ant_act_wifi_not_conn_asso_auth(
2323                                                                      btcoexist);
2324                 } else {
2325                         btc8723b1ant_action_wifi_not_conn(btcoexist);
2326                 }
2327         } else { /* wifi LPS/Busy */
2328                 halbtc8723b1ant_action_wifi_connected(btcoexist);
2329         }
2330 }
2331
2332 /* force coex mechanism to reset */
2333 static void halbtc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist)
2334 {
2335         /* sw all off */
2336         halbtc8723b1ant_sw_mechanism(btcoexist, false);
2337
2338         coex_sta->pop_event_cnt = 0;
2339 }
2340
2341 static void halbtc8723b1ant_init_hw_config(struct btc_coexist *btcoexist,
2342                                            bool backup, bool wifi_only)
2343 {
2344         struct rtl_priv *rtlpriv = btcoexist->adapter;
2345         u32 u32tmp = 0;
2346         u8 u8tmpa = 0, u8tmpb = 0;
2347
2348         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2349                  "[BTCoex], 1Ant Init HW Config!!\n");
2350
2351         /* 0xf0[15:12] --> Chip Cut information */
2352         coex_sta->cut_version =
2353                 (btcoexist->btc_read_1byte(btcoexist, 0xf1) & 0xf0) >> 4;
2354         /* enable TBTT interrupt */
2355         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8, 0x1);
2356
2357         /* 0x790[5:0] = 0x5 */
2358         btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
2359
2360         /* Enable counter statistics */
2361         btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
2362         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
2363
2364         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2365
2366         /* Antenna config */
2367         if (wifi_only)
2368                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
2369                                              FORCE_EXEC, true, false);
2370         else
2371                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2372                                              FORCE_EXEC, true, false);
2373
2374         /* PTA parameter */
2375         halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2376
2377         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
2378         u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
2379         u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
2380
2381         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2382                  "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
2383                  u32tmp, u8tmpa, u8tmpb);
2384 }
2385
2386 /**************************************************************
2387  * extern function start with ex_btc8723b1ant_
2388  **************************************************************/
2389 void ex_btc8723b1ant_power_on_setting(struct btc_coexist *btcoexist)
2390 {
2391         struct rtl_priv *rtlpriv = btcoexist->adapter;
2392         struct btc_board_info *board_info = &btcoexist->board_info;
2393         u8 u8tmp = 0x0;
2394         u16 u16tmp = 0x0;
2395         u32 value;
2396
2397         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2398                  "xxxxxxxxxxxxxxxx Execute 8723b 1-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
2399
2400         btcoexist->stop_coex_dm = true;
2401
2402         btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
2403
2404         /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
2405         u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
2406         btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT0 | BIT1);
2407
2408         /* set GRAN_BT = 1 */
2409         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
2410         /* set WLAN_ACT = 0 */
2411         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
2412
2413         /* S0 or S1 setting and Local register setting(By the setting fw can get
2414          * ant number, S0/S1, ... info)
2415          *
2416          * Local setting bit define
2417          *      BIT0: "0" for no antenna inverse; "1" for antenna inverse
2418          *      BIT1: "0" for internal switch; "1" for external switch
2419          *      BIT2: "0" for one antenna; "1" for two antenna
2420          * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
2421          * BIT2 = 0
2422          */
2423         if (btcoexist->chip_interface == BTC_INTF_USB) {
2424                 /* fixed at S0 for USB interface */
2425                 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
2426
2427                 u8tmp |= 0x1; /* antenna inverse */
2428                 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
2429
2430                 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
2431         } else {
2432                 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
2433                 if (board_info->single_ant_path == 0) {
2434                         /* set to S1 */
2435                         btcoexist->btc_write_4byte(btcoexist, 0x948, 0x280);
2436                         board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
2437                         value = 1;
2438                 } else if (board_info->single_ant_path == 1) {
2439                         /* set to S0 */
2440                         btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
2441                         u8tmp |= 0x1; /* antenna inverse */
2442                         board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
2443                         value = 0;
2444                 }
2445
2446                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
2447                                    &value);
2448
2449                 if (btcoexist->chip_interface == BTC_INTF_PCI)
2450                         btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
2451                                                              u8tmp);
2452                 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
2453                         btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
2454                                                              u8tmp);
2455         }
2456 }
2457
2458
2459 void ex_btc8723b1ant_init_hwconfig(struct btc_coexist *btcoexist,
2460                                    bool wifi_only)
2461 {
2462         halbtc8723b1ant_init_hw_config(btcoexist, true, wifi_only);
2463         btcoexist->stop_coex_dm = false;
2464 }
2465
2466 void ex_btc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist)
2467 {
2468         struct rtl_priv *rtlpriv = btcoexist->adapter;
2469
2470         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2471                  "[BTCoex], Coex Mechanism Init!!\n");
2472
2473         btcoexist->stop_coex_dm = false;
2474
2475         halbtc8723b1ant_init_coex_dm(btcoexist);
2476
2477         halbtc8723b1ant_query_bt_info(btcoexist);
2478 }
2479
2480 void ex_btc8723b1ant_display_coex_info(struct btc_coexist *btcoexist)
2481 {
2482         struct btc_board_info *board_info = &btcoexist->board_info;
2483         struct btc_stack_info *stack_info = &btcoexist->stack_info;
2484         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2485         struct rtl_priv *rtlpriv = btcoexist->adapter;
2486         u8 u8tmp[4], i, bt_info_ext, pstdmacase = 0;
2487         u16 u16tmp[4];
2488         u32 u32tmp[4];
2489         bool roam = false, scan = false;
2490         bool link = false, wifi_under_5g = false;
2491         bool bt_hs_on = false, wifi_busy = false;
2492         s32 wifi_rssi = 0, bt_hs_rssi = 0;
2493         u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck, wifi_link_status;
2494         u8 wifi_dot11_chnl, wifi_hs_chnl;
2495         u32 fw_ver = 0, bt_patch_ver = 0;
2496
2497         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2498                  "\r\n ============[BT Coexist info]============");
2499
2500         if (btcoexist->manual_control) {
2501                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2502                          "\r\n ============[Under Manual Control]==========");
2503                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2504                          "\r\n ==========================================");
2505         }
2506         if (btcoexist->stop_coex_dm) {
2507                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2508                          "\r\n ============[Coex is STOPPED]============");
2509                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2510                          "\r\n ==========================================");
2511         }
2512
2513         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d",
2514                  "Ant PG Num/ Ant Mech/ Ant Pos:",
2515                  board_info->pg_ant_num, board_info->btdm_ant_num,
2516                  board_info->btdm_ant_pos);
2517
2518         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
2519                  "BT stack/ hci ext ver",
2520                  ((stack_info->profile_notified) ? "Yes" : "No"),
2521                  stack_info->hci_version);
2522
2523         btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
2524         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2525         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2526                  "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2527                  "CoexVer/ FwVer/ PatchVer",
2528                  glcoex_ver_date_8723b_1ant, glcoex_ver_8723b_1ant,
2529                  fw_ver, bt_patch_ver, bt_patch_ver);
2530
2531         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2532         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
2533                            &wifi_dot11_chnl);
2534         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
2535         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
2536                  "Dot11 channel / HsChnl(HsMode)",
2537                  wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
2538
2539         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %3ph ",
2540                  "H2C Wifi inform bt chnl Info",
2541                  coex_dm->wifi_chnl_info);
2542
2543         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
2544         btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
2545         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
2546                  "Wifi rssi/ HS rssi", wifi_rssi, bt_hs_rssi);
2547
2548         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2549         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2550         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2551         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
2552                  "Wifi link/ roam/ scan", link, roam, scan);
2553
2554         btcoexist->btc_get(btcoexist , BTC_GET_BL_WIFI_UNDER_5G,
2555                            &wifi_under_5g);
2556         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2557         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2558         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
2559                            &wifi_traffic_dir);
2560
2561         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
2562                  "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
2563                  ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
2564                   ((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20")),
2565                   ((!wifi_busy) ? "idle" :
2566                    ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
2567                    "uplink" : "downlink")));
2568
2569         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2570                            &wifi_link_status);
2571         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
2572                  "sta/vwifi/hs/p2pGo/p2pGc",
2573                  ((wifi_link_status & WIFI_STA_CONNECTED) ? 1 : 0),
2574                  ((wifi_link_status & WIFI_AP_CONNECTED) ? 1 : 0),
2575                  ((wifi_link_status & WIFI_HS_CONNECTED) ? 1 : 0),
2576                  ((wifi_link_status & WIFI_P2P_GO_CONNECTED) ? 1 : 0),
2577                  ((wifi_link_status & WIFI_P2P_GC_CONNECTED) ? 1 : 0));
2578
2579         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = [%s/ %d/ %d] ",
2580                  "BT [status/ rssi/ retryCnt]",
2581                  ((coex_sta->bt_disabled) ? ("disabled") :
2582                   ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") :
2583                    ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2584                      coex_dm->bt_status) ?
2585                     "non-connected idle" :
2586                     ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2587                       coex_dm->bt_status) ?
2588                      "connected-idle" : "busy")))),
2589                      coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
2590
2591         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2592                  "\r\n %-35s = %d / %d / %d / %d",
2593                  "SCO/HID/PAN/A2DP", bt_link_info->sco_exist,
2594                  bt_link_info->hid_exist, bt_link_info->pan_exist,
2595                  bt_link_info->a2dp_exist);
2596         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
2597
2598         bt_info_ext = coex_sta->bt_info_ext;
2599         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
2600                  "BT Info A2DP rate",
2601                  (bt_info_ext & BIT0) ? "Basic rate" : "EDR rate");
2602
2603         for (i = 0; i < BT_INFO_SRC_8723B_1ANT_MAX; i++) {
2604                 if (coex_sta->bt_info_c2h_cnt[i]) {
2605                         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2606                                  "\r\n %-35s = %7ph(%d)",
2607                                  glbt_info_src_8723b_1ant[i],
2608                                  coex_sta->bt_info_c2h[i],
2609                                  coex_sta->bt_info_c2h_cnt[i]);
2610                 }
2611         }
2612         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2613                  "\r\n %-35s = %s/%s, (0x%x/0x%x)",
2614                  "PS state, IPS/LPS, (lps/rpwm)",
2615                  ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
2616                  ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")),
2617                  btcoexist->bt_info.lps_val,
2618                  btcoexist->bt_info.rpwm_val);
2619         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
2620
2621         if (!btcoexist->manual_control) {
2622                 /* Sw mechanism */
2623                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
2624                          "============[Sw mechanism]============");
2625
2626                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/",
2627                          "SM[LowPenaltyRA]", coex_dm->cur_low_penalty_ra);
2628
2629                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/ %s/ %d ",
2630                          "DelBA/ BtCtrlAgg/ AggSize",
2631                            (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"),
2632                            (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"),
2633                            btcoexist->bt_info.agg_buf_size);
2634
2635                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x ",
2636                          "Rate Mask", btcoexist->bt_info.ra_mask);
2637
2638                 /* Fw mechanism */
2639                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
2640                          "============[Fw mechanism]============");
2641
2642                 pstdmacase = coex_dm->cur_ps_tdma;
2643                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2644                          "\r\n %-35s = %5ph case-%d (auto:%d)",
2645                            "PS TDMA", coex_dm->ps_tdma_para,
2646                            pstdmacase, coex_dm->auto_tdma_adjust);
2647
2648                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d ",
2649                          "IgnWlanAct", coex_dm->cur_ignore_wlan_act);
2650
2651                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x ",
2652                          "Latest error condition(should be 0)",
2653                            coex_dm->error_condition);
2654         }
2655
2656         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d",
2657                  "Coex Table Type", coex_sta->coex_table_type);
2658
2659         /* Hw setting */
2660         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
2661                  "============[Hw setting]============");
2662
2663         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2664                  "backup ARFR1/ARFR2/RL/AMaxTime", coex_dm->backup_arfr_cnt1,
2665                    coex_dm->backup_arfr_cnt2, coex_dm->backup_retry_limit,
2666                    coex_dm->backup_ampdu_max_time);
2667
2668         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
2669         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
2670         u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
2671         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
2672         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2673                  "0x430/0x434/0x42a/0x456",
2674                  u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
2675
2676         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
2677         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
2678         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x880);
2679         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2680                  "0x778/0x6cc/0x880[29:25]", u8tmp[0], u32tmp[0],
2681                  (u32tmp[1] & 0x3e000000) >> 25);
2682
2683         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
2684         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
2685         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
2686         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2687                  "0x948/ 0x67[5] / 0x765",
2688                  u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]);
2689
2690         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
2691         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
2692         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
2693         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2694                  "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
2695                  u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
2696
2697         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
2698         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
2699         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
2700         u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
2701         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2702                  "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2703                  "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
2704                  ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
2705                   ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
2706
2707         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
2708         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
2709         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
2710                  "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
2711
2712         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
2713         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
2714         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
2715                  "0xc50(dig)/0x49c(null-drop)", u32tmp[0] & 0xff, u8tmp[0]);
2716
2717         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
2718         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
2719         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
2720         u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
2721
2722         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
2723         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
2724
2725         fa_ofdm = ((u32tmp[0] & 0xffff0000) >> 16) +
2726                   ((u32tmp[1] & 0xffff0000) >> 16) +
2727                    (u32tmp[1] & 0xffff) +
2728                    (u32tmp[2] & 0xffff) +
2729                   ((u32tmp[3] & 0xffff0000) >> 16) +
2730                    (u32tmp[3] & 0xffff);
2731         fa_cck = (u8tmp[0] << 8) + u8tmp[1];
2732
2733         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2734                  "OFDM-CCA/OFDM-FA/CCK-FA",
2735                  u32tmp[0] & 0xffff, fa_ofdm, fa_cck);
2736
2737         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
2738         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
2739         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
2740         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2741                  "0x6c0/0x6c4/0x6c8(coexTable)",
2742                  u32tmp[0], u32tmp[1], u32tmp[2]);
2743
2744         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
2745                  "0x770(high-pri rx/tx)", coex_sta->high_priority_rx,
2746                  coex_sta->high_priority_tx);
2747         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
2748                  "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
2749                  coex_sta->low_priority_tx);
2750         if (btcoexist->auto_report_1ant)
2751                 halbtc8723b1ant_monitor_bt_ctr(btcoexist);
2752         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
2753 }
2754
2755 void ex_btc8723b1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
2756 {
2757         struct rtl_priv *rtlpriv = btcoexist->adapter;
2758
2759         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2760                 return;
2761
2762         if (BTC_IPS_ENTER == type) {
2763                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2764                          "[BTCoex], IPS ENTER notify\n");
2765                 coex_sta->under_ips = true;
2766
2767                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2768                                              FORCE_EXEC, false, true);
2769                 /* set PTA control */
2770                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2771                 halbtc8723b1ant_coex_table_with_type(btcoexist,
2772                                                      NORMAL_EXEC, 0);
2773         } else if (BTC_IPS_LEAVE == type) {
2774                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2775                          "[BTCoex], IPS LEAVE notify\n");
2776                 coex_sta->under_ips = false;
2777
2778                 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
2779                 halbtc8723b1ant_init_coex_dm(btcoexist);
2780                 halbtc8723b1ant_query_bt_info(btcoexist);
2781         }
2782 }
2783
2784 void ex_btc8723b1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
2785 {
2786         struct rtl_priv *rtlpriv = btcoexist->adapter;
2787
2788         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2789                 return;
2790
2791         if (BTC_LPS_ENABLE == type) {
2792                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2793                          "[BTCoex], LPS ENABLE notify\n");
2794                 coex_sta->under_lps = true;
2795         } else if (BTC_LPS_DISABLE == type) {
2796                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2797                          "[BTCoex], LPS DISABLE notify\n");
2798                 coex_sta->under_lps = false;
2799         }
2800 }
2801
2802 void ex_btc8723b1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
2803 {
2804         struct rtl_priv *rtlpriv = btcoexist->adapter;
2805         bool wifi_connected = false, bt_hs_on = false;
2806         u8 u8tmpa, u8tmpb;
2807         u32 u32tmp;
2808         u32 wifi_link_status = 0;
2809         u32 num_of_wifi_link = 0;
2810         bool bt_ctrl_agg_buf_size = false;
2811         u8 agg_buf_size = 5;
2812
2813         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2814                 return;
2815
2816         if (type == BTC_SCAN_START) {
2817                 coex_sta->wifi_is_high_pri_task = true;
2818                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2819                          "[BTCoex], SCAN START notify\n");
2820                 /* Force antenna setup for no scan result issue */
2821                 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2822                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2823                                              FORCE_EXEC, false, false);
2824                 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
2825                 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
2826                 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
2827
2828                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2829                          "[BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
2830                          u32tmp, u8tmpa, u8tmpb);
2831         } else {
2832                 coex_sta->wifi_is_high_pri_task = false;
2833                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2834                          "[BTCoex], SCAN FINISH notify\n");
2835
2836                 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2837                                    &coex_sta->scan_ap_num);
2838         }
2839
2840         if (coex_sta->bt_disabled)
2841                 return;
2842
2843         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2844         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2845                            &wifi_connected);
2846
2847         halbtc8723b1ant_query_bt_info(btcoexist);
2848
2849         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2850                            &wifi_link_status);
2851         num_of_wifi_link = wifi_link_status >> 16;
2852         if (num_of_wifi_link >= 2) {
2853                 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2854                 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2855                                            bt_ctrl_agg_buf_size, agg_buf_size);
2856                 halbtc8723b1ant_action_wifi_multiport(btcoexist);
2857                 return;
2858         }
2859
2860         if (coex_sta->c2h_bt_inquiry_page) {
2861                 halbtc8723b1ant_action_bt_inquiry(btcoexist);
2862                 return;
2863         } else if (bt_hs_on) {
2864                 halbtc8723b1ant_action_hs(btcoexist);
2865                 return;
2866         }
2867
2868         if (BTC_SCAN_START == type) {
2869                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2870                          "[BTCoex], SCAN START notify\n");
2871                 if (!wifi_connected)
2872                         /* non-connected scan */
2873                         btc8723b1ant_action_wifi_not_conn_scan(btcoexist);
2874                 else
2875                         /* wifi is connected */
2876                         btc8723b1ant_action_wifi_conn_scan(btcoexist);
2877         } else if (BTC_SCAN_FINISH == type) {
2878                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2879                          "[BTCoex], SCAN FINISH notify\n");
2880                 if (!wifi_connected)
2881                         /* non-connected scan */
2882                         btc8723b1ant_action_wifi_not_conn(btcoexist);
2883                 else
2884                         halbtc8723b1ant_action_wifi_connected(btcoexist);
2885         }
2886 }
2887
2888 void ex_btc8723b1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
2889 {
2890         struct rtl_priv *rtlpriv = btcoexist->adapter;
2891         bool wifi_connected = false, bt_hs_on = false;
2892         u32 wifi_link_status = 0;
2893         u32 num_of_wifi_link = 0;
2894         bool bt_ctrl_agg_buf_size = false, under_4way = false;
2895         u8 agg_buf_size = 5;
2896
2897         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
2898                            &under_4way);
2899
2900         if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2901             coex_sta->bt_disabled)
2902                 return;
2903
2904         if (type == BTC_ASSOCIATE_START) {
2905                 coex_sta->wifi_is_high_pri_task = true;
2906
2907                 /* Force antenna setup for no scan result issue */
2908                 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2909                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2910                                              FORCE_EXEC, false, false);
2911                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2912                          "[BTCoex], CONNECT START notify\n");
2913                 coex_dm->arp_cnt = 0;
2914         } else {
2915                 coex_sta->wifi_is_high_pri_task = false;
2916                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2917                          "[BTCoex], CONNECT FINISH notify\n");
2918         }
2919
2920         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2921                            &wifi_link_status);
2922         num_of_wifi_link = wifi_link_status>>16;
2923         if (num_of_wifi_link >= 2) {
2924                 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2925                 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2926                                            bt_ctrl_agg_buf_size, agg_buf_size);
2927                 halbtc8723b1ant_action_wifi_multiport(btcoexist);
2928                 return;
2929         }
2930
2931         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2932         if (coex_sta->c2h_bt_inquiry_page) {
2933                 halbtc8723b1ant_action_bt_inquiry(btcoexist);
2934                 return;
2935         } else if (bt_hs_on) {
2936                 halbtc8723b1ant_action_hs(btcoexist);
2937                 return;
2938         }
2939
2940         if (BTC_ASSOCIATE_START == type) {
2941                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2942                          "[BTCoex], CONNECT START notify\n");
2943                 btc8723b1ant_act_wifi_not_conn_asso_auth(btcoexist);
2944         } else if (BTC_ASSOCIATE_FINISH == type) {
2945                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2946                          "[BTCoex], CONNECT FINISH notify\n");
2947
2948                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2949                                    &wifi_connected);
2950                 if (!wifi_connected)
2951                         /* non-connected scan */
2952                         btc8723b1ant_action_wifi_not_conn(btcoexist);
2953                 else
2954                         halbtc8723b1ant_action_wifi_connected(btcoexist);
2955         }
2956 }
2957
2958 void ex_btc8723b1ant_media_status_notify(struct btc_coexist *btcoexist,
2959                                          u8 type)
2960 {
2961         struct rtl_priv *rtlpriv = btcoexist->adapter;
2962         u8 h2c_parameter[3] = {0};
2963         u32 wifi_bw;
2964         u8 wifi_central_chnl;
2965         bool wifi_under_b_mode = false;
2966
2967         if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2968             coex_sta->bt_disabled)
2969                 return;
2970
2971         if (type == BTC_MEDIA_CONNECT) {
2972                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2973                          "[BTCoex], MEDIA connect notify\n");
2974                 /* Force antenna setup for no scan result issue */
2975                 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2976                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2977                                              FORCE_EXEC, false, false);
2978                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
2979                                    &wifi_under_b_mode);
2980
2981                 /* Set CCK Tx/Rx high Pri except 11b mode */
2982                 if (wifi_under_b_mode) {
2983                         btcoexist->btc_write_1byte(btcoexist, 0x6cd,
2984                                                    0x00); /* CCK Tx */
2985                         btcoexist->btc_write_1byte(btcoexist, 0x6cf,
2986                                                    0x00); /* CCK Rx */
2987                 } else {
2988                         btcoexist->btc_write_1byte(btcoexist, 0x6cd,
2989                                                    0x00); /* CCK Tx */
2990                         btcoexist->btc_write_1byte(btcoexist, 0x6cf,
2991                                                    0x10); /* CCK Rx */
2992                 }
2993
2994                 coex_dm->backup_arfr_cnt1 =
2995                         btcoexist->btc_read_4byte(btcoexist, 0x430);
2996                 coex_dm->backup_arfr_cnt2 =
2997                         btcoexist->btc_read_4byte(btcoexist, 0x434);
2998                 coex_dm->backup_retry_limit =
2999                         btcoexist->btc_read_2byte(btcoexist, 0x42a);
3000                 coex_dm->backup_ampdu_max_time =
3001                         btcoexist->btc_read_1byte(btcoexist, 0x456);
3002         } else {
3003                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3004                          "[BTCoex], MEDIA disconnect notify\n");
3005                 coex_dm->arp_cnt = 0;
3006
3007                 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
3008                 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
3009
3010                 coex_sta->cck_ever_lock = false;
3011         }
3012
3013         /* only 2.4G we need to inform bt the chnl mask */
3014         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
3015                            &wifi_central_chnl);
3016
3017         if (type == BTC_MEDIA_CONNECT && wifi_central_chnl <= 14) {
3018                 h2c_parameter[0] = 0x0;
3019                 h2c_parameter[1] = wifi_central_chnl;
3020                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3021                 if (BTC_WIFI_BW_HT40 == wifi_bw)
3022                         h2c_parameter[2] = 0x30;
3023                 else
3024                         h2c_parameter[2] = 0x20;
3025         }
3026
3027         coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3028         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3029         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3030
3031         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3032                  "[BTCoex], FW write 0x66 = 0x%x\n",
3033                  h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3034                  h2c_parameter[2]);
3035
3036         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3037 }
3038
3039 void ex_btc8723b1ant_special_packet_notify(struct btc_coexist *btcoexist,
3040                                            u8 type)
3041 {
3042         struct rtl_priv *rtlpriv = btcoexist->adapter;
3043         bool bt_hs_on = false;
3044         u32 wifi_link_status = 0;
3045         u32 num_of_wifi_link = 0;
3046         bool bt_ctrl_agg_buf_size = false, under_4way = false;
3047         u8 agg_buf_size = 5;
3048
3049         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3050                            &under_4way);
3051
3052         if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
3053             coex_sta->bt_disabled)
3054                 return;
3055
3056         if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
3057             type == BTC_PACKET_ARP) {
3058                 if (type == BTC_PACKET_ARP) {
3059                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3060                                  "[BTCoex], special Packet ARP notify\n");
3061
3062                         coex_dm->arp_cnt++;
3063                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3064                                  "[BTCoex], ARP Packet Count = %d\n",
3065                                  coex_dm->arp_cnt);
3066
3067                         if ((coex_dm->arp_cnt >= 10) && (!under_4way))
3068                                 /* if APR PKT > 10 after connect, do not go to
3069                                  * ActionWifiConnectedSpecificPacket(btcoexist)
3070                                  */
3071                                 coex_sta->wifi_is_high_pri_task = false;
3072                         else
3073                                 coex_sta->wifi_is_high_pri_task = true;
3074                 } else {
3075                         coex_sta->wifi_is_high_pri_task = true;
3076                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3077                                  "[BTCoex], special Packet DHCP or EAPOL notify\n");
3078                 }
3079         } else {
3080                 coex_sta->wifi_is_high_pri_task = false;
3081                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3082                          "[BTCoex], special Packet [Type = %d] notify\n",
3083                          type);
3084         }
3085
3086         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3087                 &wifi_link_status);
3088         num_of_wifi_link = wifi_link_status >> 16;
3089         if (num_of_wifi_link >= 2) {
3090                 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3091                 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3092                                            bt_ctrl_agg_buf_size, agg_buf_size);
3093                 halbtc8723b1ant_action_wifi_multiport(btcoexist);
3094                 return;
3095         }
3096
3097         coex_sta->special_pkt_period_cnt = 0;
3098
3099         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3100         if (coex_sta->c2h_bt_inquiry_page) {
3101                 halbtc8723b1ant_action_bt_inquiry(btcoexist);
3102                 return;
3103         } else if (bt_hs_on) {
3104                 halbtc8723b1ant_action_hs(btcoexist);
3105                 return;
3106         }
3107
3108         if (BTC_PACKET_DHCP == type ||
3109             BTC_PACKET_EAPOL == type) {
3110                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3111                          "[BTCoex], special Packet(%d) notify\n", type);
3112                 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist);
3113         }
3114 }
3115
3116 void ex_btc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
3117                                     u8 *tmp_buf, u8 length)
3118 {
3119         struct rtl_priv *rtlpriv = btcoexist->adapter;
3120         u8 bt_info = 0;
3121         u8 i, rsp_source = 0;
3122         bool wifi_connected = false;
3123         bool bt_busy = false;
3124
3125         coex_sta->c2h_bt_info_req_sent = false;
3126
3127         rsp_source = tmp_buf[0] & 0xf;
3128         if (rsp_source >= BT_INFO_SRC_8723B_1ANT_MAX)
3129                 rsp_source = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
3130         coex_sta->bt_info_c2h_cnt[rsp_source]++;
3131
3132         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3133                  "[BTCoex], Bt info[%d], length=%d, hex data = [",
3134                  rsp_source, length);
3135         for (i = 0; i < length; i++) {
3136                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3137                 if (i == 1)
3138                         bt_info = tmp_buf[i];
3139                 if (i == length - 1)
3140                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3141                                  "0x%02x]\n", tmp_buf[i]);
3142                 else
3143                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3144                                  "0x%02x, ", tmp_buf[i]);
3145         }
3146
3147         /* if 0xff, it means BT is under WHCK test */
3148         if (bt_info == 0xff)
3149                 coex_sta->bt_whck_test = true;
3150         else
3151                 coex_sta->bt_whck_test = false;
3152
3153         if (rsp_source != BT_INFO_SRC_8723B_1ANT_WIFI_FW) {
3154                 coex_sta->bt_retry_cnt = /* [3:0] */
3155                         coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3156
3157                 if (coex_sta->bt_retry_cnt >= 1)
3158                         coex_sta->pop_event_cnt++;
3159
3160                 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
3161                         coex_sta->c2h_bt_remote_name_req = true;
3162                 else
3163                         coex_sta->c2h_bt_remote_name_req = false;
3164
3165                 coex_sta->bt_rssi =
3166                         coex_sta->bt_info_c2h[rsp_source][3] * 2 - 90;
3167
3168                 coex_sta->bt_info_ext =
3169                         coex_sta->bt_info_c2h[rsp_source][4];
3170
3171                 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49) {
3172                         coex_sta->a2dp_bit_pool =
3173                                 coex_sta->bt_info_c2h[rsp_source][6];
3174                 } else {
3175                         coex_sta->a2dp_bit_pool = 0;
3176                 }
3177
3178                 coex_sta->bt_tx_rx_mask =
3179                         (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
3180                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
3181                                    &coex_sta->bt_tx_rx_mask);
3182
3183                 if (!coex_sta->bt_tx_rx_mask) {
3184                         /* BT into is responded by BT FW and BT RF REG
3185                          * 0x3C != 0x15 => Need to switch BT TRx Mask
3186                          */
3187                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3188                                  "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
3189                         btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
3190                                                   0x3c, 0x15);
3191
3192                         /* BT TRx Mask lock 0x2c[0], 0x30[0] = 0 */
3193                         btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
3194                                                   0x2c, 0x7c44);
3195                         btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
3196                                                   0x30, 0x7c44);
3197                 }
3198
3199                 /* Here we need to resend some wifi info to BT
3200                  * because bt is reset and loss of the info.
3201                  */
3202                 if (coex_sta->bt_info_ext & BIT1) {
3203                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3204                                  "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
3205                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3206                                            &wifi_connected);
3207                         if (wifi_connected)
3208                                 ex_btc8723b1ant_media_status_notify(btcoexist,
3209                                                 BTC_MEDIA_CONNECT);
3210                         else
3211                                 ex_btc8723b1ant_media_status_notify(btcoexist,
3212                                                 BTC_MEDIA_DISCONNECT);
3213                 }
3214
3215                 if (coex_sta->bt_info_ext & BIT3) {
3216                         if (!btcoexist->manual_control &&
3217                             !btcoexist->stop_coex_dm) {
3218                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3219                                          "[BTCoex], BT ext info bit3 check, set BT NOT ignore Wlan active!!\n");
3220                                 halbtc8723b1ant_ignore_wlan_act(btcoexist,
3221                                                                 FORCE_EXEC,
3222                                                                 false);
3223                         }
3224                 } else {
3225                         /* BT already NOT ignore Wlan active, do nothing here.*/
3226                 }
3227                 if (!btcoexist->auto_report_1ant) {
3228                         if (coex_sta->bt_info_ext & BIT4) {
3229                                 /* BT auto report already enabled, do nothing */
3230                         } else {
3231                                 halbtc8723b1ant_bt_auto_report(btcoexist,
3232                                                                FORCE_EXEC,
3233                                                                true);
3234                         }
3235                 }
3236         }
3237
3238         /* check BIT2 first ==> check if bt is under inquiry or page scan */
3239         if (bt_info & BT_INFO_8723B_1ANT_B_INQ_PAGE)
3240                 coex_sta->c2h_bt_inquiry_page = true;
3241         else
3242                 coex_sta->c2h_bt_inquiry_page = false;
3243
3244         coex_sta->num_of_profile = 0;
3245
3246         /* set link exist status */
3247         if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) {
3248                 coex_sta->bt_link_exist = false;
3249                 coex_sta->pan_exist = false;
3250                 coex_sta->a2dp_exist = false;
3251                 coex_sta->hid_exist = false;
3252                 coex_sta->sco_exist = false;
3253
3254                 coex_sta->bt_hi_pri_link_exist = false;
3255         } else {
3256                 /* connection exists */
3257                 coex_sta->bt_link_exist = true;
3258                 if (bt_info & BT_INFO_8723B_1ANT_B_FTP) {
3259                         coex_sta->pan_exist = true;
3260                         coex_sta->num_of_profile++;
3261                 } else {
3262                         coex_sta->pan_exist = false;
3263                 }
3264                 if (bt_info & BT_INFO_8723B_1ANT_B_A2DP) {
3265                         coex_sta->a2dp_exist = true;
3266                         coex_sta->num_of_profile++;
3267                 } else {
3268                         coex_sta->a2dp_exist = false;
3269                 }
3270                 if (bt_info & BT_INFO_8723B_1ANT_B_HID) {
3271                         coex_sta->hid_exist = true;
3272                         coex_sta->num_of_profile++;
3273                 } else {
3274                         coex_sta->hid_exist = false;
3275                 }
3276                 if (bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) {
3277                         coex_sta->sco_exist = true;
3278                         coex_sta->num_of_profile++;
3279                 } else {
3280                         coex_sta->sco_exist = false;
3281                 }
3282
3283                 if ((!coex_sta->hid_exist) &&
3284                     (!coex_sta->c2h_bt_inquiry_page) &&
3285                     (!coex_sta->sco_exist)) {
3286                         if (coex_sta->high_priority_tx +
3287                                     coex_sta->high_priority_rx >=
3288                             160) {
3289                                 coex_sta->hid_exist = true;
3290                                 coex_sta->wrong_profile_notification++;
3291                                 coex_sta->num_of_profile++;
3292                                 bt_info = bt_info | 0x28;
3293                         }
3294                 }
3295
3296                 /* Add Hi-Pri Tx/Rx counter to avoid false detection */
3297                 if (((coex_sta->hid_exist) || (coex_sta->sco_exist)) &&
3298                     (coex_sta->high_priority_tx + coex_sta->high_priority_rx >=
3299                      160) &&
3300                     (!coex_sta->c2h_bt_inquiry_page))
3301                         coex_sta->bt_hi_pri_link_exist = true;
3302
3303                 if ((bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) &&
3304                     (coex_sta->num_of_profile == 0)) {
3305                         if (coex_sta->low_priority_tx +
3306                                     coex_sta->low_priority_rx >=
3307                             160) {
3308                                 coex_sta->pan_exist = true;
3309                                 coex_sta->num_of_profile++;
3310                                 coex_sta->wrong_profile_notification++;
3311                                 bt_info = bt_info | 0x88;
3312                         }
3313                 }
3314         }
3315
3316         halbtc8723b1ant_update_bt_link_info(btcoexist);
3317
3318         /* mask profile bit for connect-ilde identification
3319          * ( for CSR case: A2DP idle --> 0x41)
3320          */
3321         bt_info = bt_info & 0x1f;
3322
3323         if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) {
3324                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
3325                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3326                          "[BTCoex], BtInfoNotify(), BT Non-Connected idle!\n");
3327         /* connection exists but no busy */
3328         } else if (bt_info == BT_INFO_8723B_1ANT_B_CONNECTION) {
3329                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
3330                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3331                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3332         } else if ((bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
3333                 (bt_info & BT_INFO_8723B_1ANT_B_SCO_BUSY)) {
3334                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
3335                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3336                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3337         } else if (bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
3338                 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
3339                         coex_dm->auto_tdma_adjust = false;
3340
3341                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
3342                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3343                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3344         } else {
3345                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_MAX;
3346                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3347                          "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n");
3348         }
3349
3350         if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3351             (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3352             (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
3353                 bt_busy = true;
3354         else
3355                 bt_busy = false;
3356         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3357
3358         halbtc8723b1ant_run_coexist_mechanism(btcoexist);
3359 }
3360
3361 void ex_btc8723b1ant_rf_status_notify(struct btc_coexist *btcoexist, u8 type)
3362 {
3363         struct rtl_priv *rtlpriv = btcoexist->adapter;
3364         u32 u32tmp;
3365         u8 u8tmpa, u8tmpb, u8tmpc;
3366
3367         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3368                  "[BTCoex], RF Status notify\n");
3369
3370         if (type == BTC_RF_ON) {
3371                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3372                          "[BTCoex], RF is turned ON!!\n");
3373                 btcoexist->stop_coex_dm = false;
3374         } else if (type == BTC_RF_OFF) {
3375                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3376                          "[BTCoex], RF is turned OFF!!\n");
3377
3378                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3379                                                  0x0, 0x0);
3380                 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
3381                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
3382                                              FORCE_EXEC, false, true);
3383
3384                 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3385                 btcoexist->stop_coex_dm = true;
3386
3387                 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
3388                 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
3389                 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
3390                 u8tmpc = btcoexist->btc_read_1byte(btcoexist, 0x76e);
3391
3392                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3393                          "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x, 0x76e=0x%x\n",
3394                          u32tmp, u8tmpa, u8tmpb, u8tmpc);
3395         }
3396 }
3397
3398 void ex_btc8723b1ant_halt_notify(struct btc_coexist *btcoexist)
3399 {
3400         struct rtl_priv *rtlpriv = btcoexist->adapter;
3401
3402         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n");
3403
3404         btcoexist->stop_coex_dm = true;
3405
3406         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, FORCE_EXEC,
3407                                      false, true);
3408
3409         halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3410
3411         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3412                                          0x0, 0x0);
3413         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
3414
3415         ex_btc8723b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3416
3417         btcoexist->stop_coex_dm = true;
3418 }
3419
3420 void ex_btc8723b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
3421 {
3422         struct rtl_priv *rtlpriv = btcoexist->adapter;
3423
3424         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
3425
3426         if (BTC_WIFI_PNP_SLEEP == pnp_state) {
3427                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3428                          "[BTCoex], Pnp notify to SLEEP\n");
3429                 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
3430                                              FORCE_EXEC, false, true);
3431                 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3432                                                  0x0, 0x0);
3433                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3434                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
3435
3436                 /* Driver do not leave IPS/LPS when driver is going to sleep, so
3437                  * BTCoexistence think wifi is still under IPS/LPS
3438                  *
3439                  * BT should clear UnderIPS/UnderLPS state to avoid mismatch
3440                  * state after wakeup.
3441                  */
3442                 coex_sta->under_ips = false;
3443                 coex_sta->under_lps = false;
3444                 btcoexist->stop_coex_dm = true;
3445         } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
3446                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3447                          "[BTCoex], Pnp notify to WAKE UP\n");
3448                 btcoexist->stop_coex_dm = false;
3449                 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
3450                 halbtc8723b1ant_init_coex_dm(btcoexist);
3451                 halbtc8723b1ant_query_bt_info(btcoexist);
3452         }
3453 }
3454
3455 void ex_btc8723b1ant_coex_dm_reset(struct btc_coexist *btcoexist)
3456 {
3457         struct rtl_priv *rtlpriv = btcoexist->adapter;
3458
3459         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3460                  "[BTCoex], *****************Coex DM Reset****************\n");
3461
3462         halbtc8723b1ant_init_hw_config(btcoexist, false, false);
3463         halbtc8723b1ant_init_coex_dm(btcoexist);
3464 }
3465
3466 void ex_btc8723b1ant_periodical(struct btc_coexist *btcoexist)
3467 {
3468         struct rtl_priv *rtlpriv = btcoexist->adapter;
3469         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3470
3471         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3472                  "[BTCoex], ==========================Periodical===========================\n");
3473
3474         if (!btcoexist->auto_report_1ant) {
3475                 halbtc8723b1ant_query_bt_info(btcoexist);
3476                 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist);
3477         } else {
3478                 halbtc8723b1ant_monitor_bt_ctr(btcoexist);
3479                 halbtc8723b1ant_monitor_wifi_ctr(btcoexist);
3480
3481                 if ((coex_sta->high_priority_tx + coex_sta->high_priority_rx < 50) &&
3482                     bt_link_info->hid_exist)
3483                         bt_link_info->hid_exist = false;
3484
3485                 if (btc8723b1ant_is_wifi_status_changed(btcoexist) ||
3486                     coex_dm->auto_tdma_adjust) {
3487                         halbtc8723b1ant_run_coexist_mechanism(btcoexist);
3488                 }
3489                 coex_sta->special_pkt_period_cnt++;
3490         }
3491 }