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

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