rtlwifi/btcoexist/halbtc8723b1ant.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 2012  Realtek Corporation.*/
0003
0004 /***************************************************************
0005  * Description:
0006  *
0007  * This file is for RTL8723B Co-exist mechanism
0008  *
0009  * History
0010  * 2012/11/15 Cosa first check in.
0011  *
0012  ***************************************************************/
0013
0014 /***************************************************************
0015  * include files
0016  ***************************************************************/
0017 #include "halbt_precomp.h"
0018 /***************************************************************
0019  * Global variables, these are static variables
0020  ***************************************************************/
0021 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant;
0022 static struct coex_dm_8723b_1ant *coex_dm = &glcoex_dm_8723b_1ant;
0023 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant;
0024 static struct coex_sta_8723b_1ant *coex_sta = &glcoex_sta_8723b_1ant;
0025
0026 static const char *const glbt_info_src_8723b_1ant[] = {
0027     "BT Info[wifi fw]",
0028     "BT Info[bt rsp]",
0029     "BT Info[bt auto report]",
0030 };
0031
0032 static u32 glcoex_ver_date_8723b_1ant = 20130918;
0033 static u32 glcoex_ver_8723b_1ant = 0x47;
0034
0035 /***************************************************************
0036  * local function proto type if needed
0037  ***************************************************************/
0038 /***************************************************************
0039  * local function start with halbtc8723b1ant_
0040  ***************************************************************/
0041
0042 static void halbtc8723b1ant_updatera_mask(struct btc_coexist *btcoexist,
0043                       bool force_exec, u32 dis_rate_mask)
0044 {
0045     coex_dm->curra_mask = dis_rate_mask;
0046
0047     if (force_exec || (coex_dm->prera_mask != coex_dm->curra_mask))
0048         btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
0049                    &coex_dm->curra_mask);
0050
0051     coex_dm->prera_mask = coex_dm->curra_mask;
0052 }
0053
0054 static void btc8723b1ant_auto_rate_fb_retry(struct btc_coexist *btcoexist,
0055                         bool force_exec, u8 type)
0056 {
0057     bool wifi_under_bmode = false;
0058
0059     coex_dm->cur_arfr_type = type;
0060
0061     if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
0062         switch (coex_dm->cur_arfr_type) {
0063         case 0: /* normal mode */
0064             btcoexist->btc_write_4byte(btcoexist, 0x430,
0065                            coex_dm->backup_arfr_cnt1);
0066             btcoexist->btc_write_4byte(btcoexist, 0x434,
0067                            coex_dm->backup_arfr_cnt2);
0068             break;
0069         case 1:
0070             btcoexist->btc_get(btcoexist,
0071                        BTC_GET_BL_WIFI_UNDER_B_MODE,
0072                        &wifi_under_bmode);
0073             if (wifi_under_bmode) {
0074                 btcoexist->btc_write_4byte(btcoexist,
0075                                0x430, 0x0);
0076                 btcoexist->btc_write_4byte(btcoexist,
0077                                0x434, 0x01010101);
0078             } else {
0079                 btcoexist->btc_write_4byte(btcoexist,
0080                                0x430, 0x0);
0081                 btcoexist->btc_write_4byte(btcoexist,
0082                                0x434, 0x04030201);
0083             }
0084             break;
0085         default:
0086             break;
0087         }
0088     }
0089
0090     coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
0091 }
0092
0093 static void halbtc8723b1ant_retry_limit(struct btc_coexist *btcoexist,
0094                     bool force_exec, u8 type)
0095 {
0096     coex_dm->cur_retry_limit_type = type;
0097
0098     if (force_exec || (coex_dm->pre_retry_limit_type !=
0099                coex_dm->cur_retry_limit_type)) {
0100         switch (coex_dm->cur_retry_limit_type) {
0101         case 0: /* normal mode */
0102             btcoexist->btc_write_2byte(btcoexist, 0x42a,
0103                            coex_dm->backup_retry_limit);
0104             break;
0105         case 1: /* retry limit = 8 */
0106             btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
0107             break;
0108         default:
0109             break;
0110         }
0111     }
0112
0113     coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
0114 }
0115
0116 static void halbtc8723b1ant_ampdu_maxtime(struct btc_coexist *btcoexist,
0117                       bool force_exec, u8 type)
0118 {
0119     coex_dm->cur_ampdu_time_type = type;
0120
0121     if (force_exec || (coex_dm->pre_ampdu_time_type !=
0122         coex_dm->cur_ampdu_time_type)) {
0123         switch (coex_dm->cur_ampdu_time_type) {
0124         case 0: /* normal mode */
0125             btcoexist->btc_write_1byte(btcoexist, 0x456,
0126                     coex_dm->backup_ampdu_max_time);
0127             break;
0128         case 1: /* AMPDU timw = 0x38 * 32us */
0129             btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
0130             break;
0131         default:
0132             break;
0133         }
0134     }
0135
0136     coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
0137 }
0138
0139 static void halbtc8723b1ant_limited_tx(struct btc_coexist *btcoexist,
0140                        bool force_exec, u8 ra_masktype,
0141                        u8 arfr_type, u8 retry_limit_type,
0142                        u8 ampdu_time_type)
0143 {
0144     switch (ra_masktype) {
0145     case 0: /* normal mode */
0146         halbtc8723b1ant_updatera_mask(btcoexist, force_exec, 0x0);
0147         break;
0148     case 1: /* disable cck 1/2 */
0149         halbtc8723b1ant_updatera_mask(btcoexist, force_exec,
0150                           0x00000003);
0151         break;
0152     /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
0153     case 2:
0154         halbtc8723b1ant_updatera_mask(btcoexist, force_exec,
0155                           0x0001f1f7);
0156         break;
0157     default:
0158         break;
0159     }
0160
0161     btc8723b1ant_auto_rate_fb_retry(btcoexist, force_exec, arfr_type);
0162     halbtc8723b1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
0163     halbtc8723b1ant_ampdu_maxtime(btcoexist, force_exec, ampdu_time_type);
0164 }
0165
0166 static void halbtc8723b1ant_limited_rx(struct btc_coexist *btcoexist,
0167                        bool force_exec, bool rej_ap_agg_pkt,
0168                        bool bt_ctrl_agg_buf_size,
0169                        u8 agg_buf_size)
0170 {
0171     bool reject_rx_agg = rej_ap_agg_pkt;
0172     bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
0173     u8 rxaggsize = agg_buf_size;
0174
0175     /**********************************************
0176      *  Rx Aggregation related setting
0177      **********************************************/
0178     btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
0179                &reject_rx_agg);
0180     /* decide BT control aggregation buf size or not  */
0181     btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
0182                &bt_ctrl_rx_agg_size);
0183     /* aggregation buf size, only work
0184      * when BT control Rx aggregation size.
0185      */
0186     btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxaggsize);
0187     /* real update aggregation setting  */
0188     btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
0189 }
0190
0191 static void halbtc8723b1ant_query_bt_info(struct btc_coexist *btcoexist)
0192 {
0193     u8 h2c_parameter[1] = {0};
0194
0195     coex_sta->c2h_bt_info_req_sent = true;
0196
0197     /* trigger */
0198     h2c_parameter[0] |= BIT(0);
0199
0200     btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
0201 }
0202
0203 static void halbtc8723b1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
0204 {
0205     u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
0206     u32 reg_hp_tx = 0, reg_hp_rx = 0;
0207     u32 reg_lp_tx = 0, reg_lp_rx = 0;
0208     static u32 num_of_bt_counter_chk;
0209
0210     reg_hp_txrx = 0x770;
0211     reg_lp_txrx = 0x774;
0212
0213     u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
0214     reg_hp_tx = u32tmp & MASKLWORD;
0215     reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
0216
0217     u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
0218     reg_lp_tx = u32tmp & MASKLWORD;
0219     reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
0220
0221     coex_sta->high_priority_tx = reg_hp_tx;
0222     coex_sta->high_priority_rx = reg_hp_rx;
0223     coex_sta->low_priority_tx = reg_lp_tx;
0224     coex_sta->low_priority_rx = reg_lp_rx;
0225
0226     if ((coex_sta->low_priority_tx > 1050) &&
0227         (!coex_sta->c2h_bt_inquiry_page))
0228         coex_sta->pop_event_cnt++;
0229
0230     /* reset counter */
0231     btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
0232
0233     /* This part is for wifi FW and driver to update BT's status as
0234      * disabled.
0235      *
0236      * The flow is as the following
0237      * 1. disable BT
0238      * 2. if all BT Tx/Rx counter = 0, after 6 sec we query bt info
0239      * 3. Because BT will not rsp from mailbox, so wifi fw will know BT is
0240      * disabled
0241      *
0242      * 4. FW will rsp c2h for BT that driver will know BT is disabled.
0243      */
0244     if ((reg_hp_tx == 0) && (reg_hp_rx == 0) && (reg_lp_tx == 0) &&
0245         (reg_lp_rx == 0)) {
0246         num_of_bt_counter_chk++;
0247         if (num_of_bt_counter_chk == 3)
0248             halbtc8723b1ant_query_bt_info(btcoexist);
0249     } else {
0250         num_of_bt_counter_chk = 0;
0251     }
0252 }
0253
0254 static void halbtc8723b1ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
0255 {
0256     s32 wifi_rssi = 0;
0257     bool wifi_busy = false, wifi_under_b_mode = false;
0258     static u8 cck_lock_counter;
0259     u32 total_cnt;
0260
0261     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
0262     btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
0263     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
0264                &wifi_under_b_mode);
0265
0266     if (coex_sta->under_ips) {
0267         coex_sta->crc_ok_cck = 0;
0268         coex_sta->crc_ok_11g = 0;
0269         coex_sta->crc_ok_11n = 0;
0270         coex_sta->crc_ok_11n_agg = 0;
0271
0272         coex_sta->crc_err_cck = 0;
0273         coex_sta->crc_err_11g = 0;
0274         coex_sta->crc_err_11n = 0;
0275         coex_sta->crc_err_11n_agg = 0;
0276     } else {
0277         coex_sta->crc_ok_cck =
0278             btcoexist->btc_read_4byte(btcoexist, 0xf88);
0279         coex_sta->crc_ok_11g =
0280             btcoexist->btc_read_2byte(btcoexist, 0xf94);
0281         coex_sta->crc_ok_11n =
0282             btcoexist->btc_read_2byte(btcoexist, 0xf90);
0283         coex_sta->crc_ok_11n_agg =
0284             btcoexist->btc_read_2byte(btcoexist, 0xfb8);
0285
0286         coex_sta->crc_err_cck =
0287             btcoexist->btc_read_4byte(btcoexist, 0xf84);
0288         coex_sta->crc_err_11g =
0289             btcoexist->btc_read_2byte(btcoexist, 0xf96);
0290         coex_sta->crc_err_11n =
0291             btcoexist->btc_read_2byte(btcoexist, 0xf92);
0292         coex_sta->crc_err_11n_agg =
0293             btcoexist->btc_read_2byte(btcoexist, 0xfba);
0294     }
0295
0296     /* reset counter */
0297     btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
0298     btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
0299
0300     if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
0301         total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
0302                 coex_sta->crc_ok_11n + coex_sta->crc_ok_11n_agg;
0303
0304         if ((coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
0305             (coex_dm->bt_status ==
0306              BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
0307             (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY)) {
0308             if (coex_sta->crc_ok_cck >
0309                 (total_cnt - coex_sta->crc_ok_cck)) {
0310                 if (cck_lock_counter < 3)
0311                     cck_lock_counter++;
0312             } else {
0313                 if (cck_lock_counter > 0)
0314                     cck_lock_counter--;
0315             }
0316
0317         } else {
0318             if (cck_lock_counter > 0)
0319                 cck_lock_counter--;
0320         }
0321     } else {
0322         if (cck_lock_counter > 0)
0323             cck_lock_counter--;
0324     }
0325
0326     if (!coex_sta->pre_ccklock) {
0327         if (cck_lock_counter >= 3)
0328             coex_sta->cck_lock = true;
0329         else
0330             coex_sta->cck_lock = false;
0331     } else {
0332         if (cck_lock_counter == 0)
0333             coex_sta->cck_lock = false;
0334         else
0335             coex_sta->cck_lock = true;
0336     }
0337
0338     if (coex_sta->cck_lock)
0339         coex_sta->cck_ever_lock = true;
0340
0341     coex_sta->pre_ccklock = coex_sta->cck_lock;
0342 }
0343
0344 static bool btc8723b1ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
0345 {
0346     static bool pre_wifi_busy;
0347     static bool pre_under_4way, pre_bt_hs_on;
0348     bool wifi_busy = false, under_4way = false, bt_hs_on = false;
0349     bool wifi_connected = false;
0350
0351     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
0352                &wifi_connected);
0353     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
0354     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
0355     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
0356                &under_4way);
0357
0358     if (wifi_connected) {
0359         if (wifi_busy != pre_wifi_busy) {
0360             pre_wifi_busy = wifi_busy;
0361             return true;
0362         }
0363         if (under_4way != pre_under_4way) {
0364             pre_under_4way = under_4way;
0365             return true;
0366         }
0367         if (bt_hs_on != pre_bt_hs_on) {
0368             pre_bt_hs_on = bt_hs_on;
0369             return true;
0370         }
0371     }
0372
0373     return false;
0374 }
0375
0376 static void halbtc8723b1ant_update_bt_link_info(struct btc_coexist *btcoexist)
0377 {
0378     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
0379     bool bt_hs_on = false;
0380
0381     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
0382
0383     bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
0384     bt_link_info->sco_exist = coex_sta->sco_exist;
0385     bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
0386     bt_link_info->pan_exist = coex_sta->pan_exist;
0387     bt_link_info->hid_exist = coex_sta->hid_exist;
0388     bt_link_info->bt_hi_pri_link_exist = coex_sta->bt_hi_pri_link_exist;
0389
0390     /* work around for HS mode. */
0391     if (bt_hs_on) {
0392         bt_link_info->pan_exist = true;
0393         bt_link_info->bt_link_exist = true;
0394     }
0395
0396     /* check if Sco only */
0397     if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
0398         !bt_link_info->pan_exist && !bt_link_info->hid_exist)
0399         bt_link_info->sco_only = true;
0400     else
0401         bt_link_info->sco_only = false;
0402
0403     /* check if A2dp only */
0404     if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
0405         !bt_link_info->pan_exist && !bt_link_info->hid_exist)
0406         bt_link_info->a2dp_only = true;
0407     else
0408         bt_link_info->a2dp_only = false;
0409
0410     /* check if Pan only */
0411     if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
0412         bt_link_info->pan_exist && !bt_link_info->hid_exist)
0413         bt_link_info->pan_only = true;
0414     else
0415         bt_link_info->pan_only = false;
0416
0417     /* check if Hid only */
0418     if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
0419         !bt_link_info->pan_exist && bt_link_info->hid_exist)
0420         bt_link_info->hid_only = true;
0421     else
0422         bt_link_info->hid_only = false;
0423 }
0424
0425 static void halbtc8723b1ant_set_bt_auto_report(struct btc_coexist *btcoexist,
0426                            bool enable_auto_report)
0427 {
0428     u8 h2c_parameter[1] = {0};
0429
0430     h2c_parameter[0] = 0;
0431
0432     if (enable_auto_report)
0433         h2c_parameter[0] |= BIT(0);
0434
0435     btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
0436 }
0437
0438 static void halbtc8723b1ant_bt_auto_report(struct btc_coexist *btcoexist,
0439                        bool force_exec,
0440                        bool enable_auto_report)
0441 {
0442     coex_dm->cur_bt_auto_report = enable_auto_report;
0443
0444     if (!force_exec) {
0445         if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
0446             return;
0447     }
0448     halbtc8723b1ant_set_bt_auto_report(btcoexist,
0449                        coex_dm->cur_bt_auto_report);
0450
0451     coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
0452 }
0453
0454 static void btc8723b1ant_set_sw_pen_tx_rate_adapt(struct btc_coexist *btcoexist,
0455                           bool low_penalty_ra)
0456 {
0457     struct rtl_priv *rtlpriv = btcoexist->adapter;
0458     u8 h2c_parameter[6] = {0};
0459
0460     h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty */
0461
0462     if (low_penalty_ra) {
0463         h2c_parameter[1] |= BIT0;
0464         /* normal rate except MCS7/6/5, OFDM54/48/36 */
0465         h2c_parameter[2] = 0x00;
0466         h2c_parameter[3] = 0xf7;  /* MCS7 or OFDM54 */
0467         h2c_parameter[4] = 0xf8;  /* MCS6 or OFDM48 */
0468         h2c_parameter[5] = 0xf9;  /* MCS5 or OFDM36 */
0469     }
0470
0471     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0472         "[BTCoex], set WiFi Low-Penalty Retry: %s",
0473         (low_penalty_ra ? "ON!!" : "OFF!!"));
0474
0475     btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
0476 }
0477
0478 static void halbtc8723b1ant_low_penalty_ra(struct btc_coexist *btcoexist,
0479                        bool force_exec, bool low_penalty_ra)
0480 {
0481     coex_dm->cur_low_penalty_ra = low_penalty_ra;
0482
0483     if (!force_exec) {
0484         if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
0485             return;
0486     }
0487     btc8723b1ant_set_sw_pen_tx_rate_adapt(btcoexist,
0488                           coex_dm->cur_low_penalty_ra);
0489
0490     coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
0491 }
0492
0493 static void halbtc8723b1ant_set_coex_table(struct btc_coexist *btcoexist,
0494                        u32 val0x6c0, u32 val0x6c4,
0495                        u32 val0x6c8, u8 val0x6cc)
0496 {
0497     struct rtl_priv *rtlpriv = btcoexist->adapter;
0498
0499     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0500         "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
0501     btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
0502
0503     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0504         "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
0505     btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
0506
0507     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0508         "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
0509     btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
0510
0511     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0512         "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
0513     btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
0514 }
0515
0516 static void halbtc8723b1ant_coex_table(struct btc_coexist *btcoexist,
0517                        bool force_exec, u32 val0x6c0,
0518                        u32 val0x6c4, u32 val0x6c8,
0519                        u8 val0x6cc)
0520 {
0521     struct rtl_priv *rtlpriv = btcoexist->adapter;
0522
0523     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0524         "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6cc = 0x%x\n",
0525          (force_exec ? "force to" : ""),
0526          val0x6c0, val0x6c4, val0x6cc);
0527     coex_dm->cur_val0x6c0 = val0x6c0;
0528     coex_dm->cur_val0x6c4 = val0x6c4;
0529     coex_dm->cur_val0x6c8 = val0x6c8;
0530     coex_dm->cur_val0x6cc = val0x6cc;
0531
0532     if (!force_exec) {
0533         if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
0534             (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
0535             (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
0536             (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
0537             return;
0538     }
0539     halbtc8723b1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
0540                        val0x6c8, val0x6cc);
0541
0542     coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
0543     coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
0544     coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
0545     coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
0546 }
0547
0548 static void halbtc8723b1ant_coex_table_with_type(struct btc_coexist *btcoexist,
0549                          bool force_exec, u8 type)
0550 {
0551     coex_sta->coex_table_type = type;
0552
0553     switch (type) {
0554     case 0:
0555         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
0556                        0x55555555, 0xffffff, 0x3);
0557         break;
0558     case 1:
0559         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
0560                        0x5a5a5a5a, 0xffffff, 0x3);
0561         break;
0562     case 2:
0563         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
0564                        0x5a5a5a5a, 0xffffff, 0x3);
0565         break;
0566     case 3:
0567         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
0568                        0x5a5a5a5a, 0xffffff, 0x3);
0569         break;
0570     case 4:
0571         if ((coex_sta->cck_ever_lock) && (coex_sta->scan_ap_num <= 5))
0572             halbtc8723b1ant_coex_table(btcoexist, force_exec,
0573                            0x55555555, 0xaaaa5a5a,
0574                            0xffffff, 0x3);
0575         else
0576             halbtc8723b1ant_coex_table(btcoexist, force_exec,
0577                            0x55555555, 0x5a5a5a5a,
0578                            0xffffff, 0x3);
0579         break;
0580     case 5:
0581         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
0582                        0x5aaa5a5a, 0xffffff, 0x3);
0583         break;
0584     case 6:
0585         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555,
0586                        0xaaaaaaaa, 0xffffff, 0x3);
0587         break;
0588     case 7:
0589         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
0590                        0xaaaaaaaa, 0xffffff, 0x3);
0591         break;
0592     case 8:
0593         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0594                        0x5ada5ada, 0xffffff, 0x3);
0595         break;
0596     case 9:
0597         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0598                        0x5ada5ada, 0xffffff, 0x3);
0599         break;
0600     case 10:
0601         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0602                        0x5ada5ada, 0xffffff, 0x3);
0603         break;
0604     case 11:
0605         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0606                        0x5ada5ada, 0xffffff, 0x3);
0607         break;
0608     case 12:
0609         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0610                        0x5ada5ada, 0xffffff, 0x3);
0611         break;
0612     case 13:
0613         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
0614                        0xaaaaaaaa, 0xffffff, 0x3);
0615         break;
0616     case 14:
0617         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
0618                        0x5ada5ada, 0xffffff, 0x3);
0619         break;
0620     case 15:
0621         halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0622                        0xaaaaaaaa, 0xffffff, 0x3);
0623         break;
0624     default:
0625         break;
0626     }
0627 }
0628
0629 static void
0630 halbtc8723b1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
0631                        bool enable)
0632 {
0633     struct rtl_priv *rtlpriv = btcoexist->adapter;
0634     u8 h2c_parameter[1] = {0};
0635
0636     if (enable)
0637         h2c_parameter[0] |= BIT0;   /* function enable */
0638
0639     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0640         "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
0641         h2c_parameter[0]);
0642
0643     btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
0644 }
0645
0646 static void halbtc8723b1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
0647                         bool force_exec, bool enable)
0648 {
0649     struct rtl_priv *rtlpriv = btcoexist->adapter;
0650
0651     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0652         "[BTCoex], %s turn Ignore WlanAct %s\n",
0653         (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
0654     coex_dm->cur_ignore_wlan_act = enable;
0655
0656     if (!force_exec) {
0657         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0658             "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
0659             coex_dm->pre_ignore_wlan_act,
0660              coex_dm->cur_ignore_wlan_act);
0661
0662         if (coex_dm->pre_ignore_wlan_act ==
0663             coex_dm->cur_ignore_wlan_act)
0664             return;
0665     }
0666     halbtc8723b1ant_set_fw_ignore_wlan_act(btcoexist, enable);
0667
0668     coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
0669 }
0670
0671 static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist,
0672                        u8 byte1, u8 byte2, u8 byte3,
0673                        u8 byte4, u8 byte5)
0674 {
0675     struct rtl_priv *rtlpriv = btcoexist->adapter;
0676     u8 h2c_parameter[5] = {0};
0677     u8 real_byte1 = byte1, real_byte5 = byte5;
0678     bool ap_enable = false;
0679
0680     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
0681                &ap_enable);
0682
0683     if (ap_enable) {
0684         if ((byte1 & BIT4) && !(byte1 & BIT5)) {
0685             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0686                 "[BTCoex], FW for 1Ant AP mode\n");
0687             real_byte1 &= ~BIT4;
0688             real_byte1 |= BIT5;
0689
0690             real_byte5 |= BIT5;
0691             real_byte5 &= ~BIT6;
0692         }
0693     }
0694
0695     h2c_parameter[0] = real_byte1;
0696     h2c_parameter[1] = byte2;
0697     h2c_parameter[2] = byte3;
0698     h2c_parameter[3] = byte4;
0699     h2c_parameter[4] = real_byte5;
0700
0701     coex_dm->ps_tdma_para[0] = real_byte1;
0702     coex_dm->ps_tdma_para[1] = byte2;
0703     coex_dm->ps_tdma_para[2] = byte3;
0704     coex_dm->ps_tdma_para[3] = byte4;
0705     coex_dm->ps_tdma_para[4] = real_byte5;
0706
0707     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0708         "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
0709         h2c_parameter[0],
0710         h2c_parameter[1] << 24 |
0711         h2c_parameter[2] << 16 |
0712         h2c_parameter[3] << 8 |
0713         h2c_parameter[4]);
0714
0715     btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
0716 }
0717
0718 static void halbtc8723b1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
0719                      u8 lps_val, u8 rpwm_val)
0720 {
0721     u8 lps = lps_val;
0722     u8 rpwm = rpwm_val;
0723
0724     btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
0725     btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
0726 }
0727
0728 static void halbtc8723b1ant_lps_rpwm(struct btc_coexist *btcoexist,
0729                      bool force_exec,
0730                      u8 lps_val, u8 rpwm_val)
0731 {
0732     struct rtl_priv *rtlpriv = btcoexist->adapter;
0733
0734     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0735         "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
0736         (force_exec ? "force to" : ""), lps_val, rpwm_val);
0737     coex_dm->cur_lps = lps_val;
0738     coex_dm->cur_rpwm = rpwm_val;
0739
0740     if (!force_exec) {
0741         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0742             "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n",
0743             coex_dm->cur_lps, coex_dm->cur_rpwm);
0744
0745         if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
0746             (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
0747             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0748                 "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n",
0749                 coex_dm->pre_rpwm, coex_dm->cur_rpwm);
0750
0751             return;
0752         }
0753     }
0754     halbtc8723b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
0755
0756     coex_dm->pre_lps = coex_dm->cur_lps;
0757     coex_dm->pre_rpwm = coex_dm->cur_rpwm;
0758 }
0759
0760 static void halbtc8723b1ant_sw_mechanism(struct btc_coexist *btcoexist,
0761                      bool low_penalty_ra)
0762 {
0763     struct rtl_priv *rtlpriv = btcoexist->adapter;
0764
0765     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0766         "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
0767
0768     halbtc8723b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
0769 }
0770
0771 static void halbtc8723b1ant_set_ant_path(struct btc_coexist *btcoexist,
0772                      u8 ant_pos_type, bool force_exec,
0773                      bool init_hw_cfg, bool wifi_off)
0774 {
0775     struct rtl_priv *rtlpriv = btcoexist->adapter;
0776     struct btc_board_info *board_info = &btcoexist->board_info;
0777     u32 fw_ver = 0, u32tmp = 0, cnt_bt_cal_chk = 0;
0778     bool pg_ext_switch = false;
0779     bool use_ext_switch = false;
0780     bool is_in_mp_mode = false;
0781     u8 h2c_parameter[2] = {0}, u8tmp = 0;
0782
0783     coex_dm->cur_ant_pos_type = ant_pos_type;
0784
0785     btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
0786     /* [31:16] = fw ver, [15:0] = fw sub ver */
0787     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
0788
0789     if ((fw_ver < 0xc0000) || pg_ext_switch)
0790         use_ext_switch = true;
0791
0792     if (init_hw_cfg) {
0793         /* WiFi TRx Mask on */
0794         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
0795                       0x780);
0796         /* remove due to interrupt is disabled that polling c2h will
0797          * fail and delay 100ms.
0798          */
0799
0800         if (fw_ver >= 0x180000) {
0801             /* Use H2C to set GNT_BT to HIGH */
0802             h2c_parameter[0] = 1;
0803             btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
0804                         h2c_parameter);
0805         } else {
0806             /* set grant_bt to high */
0807             btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
0808         }
0809         /* set wlan_act control by PTA */
0810         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
0811
0812         /* BT select s0/s1 is controlled by BT */
0813         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
0814         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
0815         btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
0816         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
0817         btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
0818     } else if (wifi_off) {
0819         if (fw_ver >= 0x180000) {
0820             /* Use H2C to set GNT_BT to HIGH */
0821             h2c_parameter[0] = 1;
0822             btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
0823                         h2c_parameter);
0824         } else {
0825             /* set grant_bt to high */
0826             btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
0827         }
0828         /* set wlan_act to always low */
0829         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
0830
0831         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
0832                    &is_in_mp_mode);
0833         if (!is_in_mp_mode)
0834             /* BT select s0/s1 is controlled by BT */
0835             btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
0836                                0x20, 0x0);
0837         else
0838             /* BT select s0/s1 is controlled by WiFi */
0839             btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
0840                                0x20, 0x1);
0841
0842         /* 0x4c[24:23]=00, Set Antenna control by BT_RFE_CTRL
0843          * BT Vendor 0xac=0xf002
0844          */
0845         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
0846         u32tmp &= ~BIT23;
0847         u32tmp &= ~BIT24;
0848         btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
0849     } else {
0850         /* Use H2C to set GNT_BT to LOW */
0851         if (fw_ver >= 0x180000) {
0852             if (btcoexist->btc_read_1byte(btcoexist, 0x765) != 0) {
0853                 h2c_parameter[0] = 0;
0854                 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
0855                             h2c_parameter);
0856             }
0857         } else {
0858             /* BT calibration check */
0859             while (cnt_bt_cal_chk <= 20) {
0860                 u8tmp = btcoexist->btc_read_1byte(btcoexist,
0861                                   0x49d);
0862                 cnt_bt_cal_chk++;
0863                 if (u8tmp & BIT(0)) {
0864                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0865                         DBG_LOUD,
0866                         "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
0867                         cnt_bt_cal_chk);
0868                     mdelay(50);
0869                 } else {
0870                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0871                         DBG_LOUD,
0872                         "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
0873                         cnt_bt_cal_chk);
0874                     break;
0875                 }
0876             }
0877
0878             /* set grant_bt to PTA */
0879             btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
0880         }
0881
0882         if (btcoexist->btc_read_1byte(btcoexist, 0x76e) != 0xc) {
0883             /* set wlan_act control by PTA */
0884             btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
0885         }
0886
0887         btcoexist->btc_write_1byte_bitmask(
0888             btcoexist, 0x67, 0x20,
0889             0x1); /* BT select s0/s1 is controlled by WiFi */
0890     }
0891
0892     if (use_ext_switch) {
0893         if (init_hw_cfg) {
0894             /* 0x4c[23] = 0, 0x4c[24] = 1
0895              * Antenna control by WL/BT
0896              */
0897             u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
0898             u32tmp &= ~BIT23;
0899             u32tmp |= BIT24;
0900             btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
0901
0902             /* fixed internal switch S1->WiFi, S0->BT */
0903             btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
0904
0905             if (board_info->btdm_ant_pos ==
0906                 BTC_ANTENNA_AT_MAIN_PORT) {
0907                 /* tell firmware "no antenna inverse" */
0908                 h2c_parameter[0] = 0;
0909                 /* ext switch type */
0910                 h2c_parameter[1] = 1;
0911                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
0912                             h2c_parameter);
0913             } else {
0914                 /* tell firmware "antenna inverse" */
0915                 h2c_parameter[0] = 1;
0916                 /* ext switch type */
0917                 h2c_parameter[1] = 1;
0918                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
0919                             h2c_parameter);
0920             }
0921         }
0922
0923         if (force_exec ||
0924             (coex_dm->cur_ant_pos_type != coex_dm->pre_ant_pos_type)) {
0925             /* ext switch setting */
0926             switch (ant_pos_type) {
0927             case BTC_ANT_PATH_WIFI:
0928                 if (board_info->btdm_ant_pos ==
0929                     BTC_ANTENNA_AT_MAIN_PORT)
0930                     btcoexist->btc_write_1byte_bitmask(
0931                         btcoexist, 0x92c, 0x3, 0x1);
0932                 else
0933                     btcoexist->btc_write_1byte_bitmask(
0934                         btcoexist, 0x92c, 0x3, 0x2);
0935                 break;
0936             case BTC_ANT_PATH_BT:
0937                 if (board_info->btdm_ant_pos ==
0938                     BTC_ANTENNA_AT_MAIN_PORT)
0939                     btcoexist->btc_write_1byte_bitmask(
0940                         btcoexist, 0x92c, 0x3, 0x2);
0941                 else
0942                     btcoexist->btc_write_1byte_bitmask(
0943                         btcoexist, 0x92c, 0x3, 0x1);
0944                 break;
0945             default:
0946             case BTC_ANT_PATH_PTA:
0947                 if (board_info->btdm_ant_pos ==
0948                     BTC_ANTENNA_AT_MAIN_PORT)
0949                     btcoexist->btc_write_1byte_bitmask(
0950                         btcoexist, 0x92c, 0x3, 0x1);
0951                 else
0952                     btcoexist->btc_write_1byte_bitmask(
0953                         btcoexist, 0x92c, 0x3, 0x2);
0954                 break;
0955             }
0956         }
0957     } else {
0958         if (init_hw_cfg) {
0959             /* 0x4c[23] = 1, 0x4c[24] = 0,
0960              * Antenna control by 0x64
0961              */
0962             u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
0963             u32tmp |= BIT23;
0964             u32tmp &= ~BIT24;
0965             btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
0966
0967             /* Fix Ext switch Main->S1, Aux->S0 */
0968             btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
0969                                0x0);
0970
0971             if (board_info->btdm_ant_pos ==
0972                 BTC_ANTENNA_AT_MAIN_PORT) {
0973                 /* tell firmware "no antenna inverse" */
0974                 h2c_parameter[0] = 0;
0975                 /* internal switch type */
0976                 h2c_parameter[1] = 0;
0977                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
0978                             h2c_parameter);
0979             } else {
0980                 /* tell firmware "antenna inverse" */
0981                 h2c_parameter[0] = 1;
0982                 /* internal switch type */
0983                 h2c_parameter[1] = 0;
0984                 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
0985                             h2c_parameter);
0986             }
0987         }
0988
0989         if (force_exec ||
0990             (coex_dm->cur_ant_pos_type != coex_dm->pre_ant_pos_type)) {
0991             /* internal switch setting */
0992             switch (ant_pos_type) {
0993             case BTC_ANT_PATH_WIFI:
0994                 if (board_info->btdm_ant_pos ==
0995                     BTC_ANTENNA_AT_MAIN_PORT)
0996                     btcoexist->btc_write_4byte(btcoexist,
0997                             0x948, 0x0);
0998                 else
0999                     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;
1428
1429     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1430         "[BTCoex], TdmaDurationAdjustForAcl()\n");
1431
1432     if ((wifi_status ==
1433          BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN) ||
1434         (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN) ||
1435         (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT)) {
1436         if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 &&
1437             coex_dm->cur_ps_tdma != 3 && coex_dm->cur_ps_tdma != 9) {
1438             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1439                         true, 9);
1440             coex_dm->ps_tdma_du_adj_type = 9;
1441
1442             up = 0;
1443             dn = 0;
1444             m = 1;
1445             n = 3;
1446             result = 0;
1447             wait_count = 0;
1448         }
1449         return;
1450     }
1451
1452     if (!coex_dm->auto_tdma_adjust) {
1453         coex_dm->auto_tdma_adjust = true;
1454         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1455             "[BTCoex], first run TdmaDurationAdjust()!!\n");
1456
1457         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1458         coex_dm->ps_tdma_du_adj_type = 2;
1459
1460         up = 0;
1461         dn = 0;
1462         m = 1;
1463         n = 3;
1464         result = 0;
1465         wait_count = 0;
1466     } else {
1467         /* acquire the BT TRx retry count from BT_Info byte2 */
1468         retry_count = coex_sta->bt_retry_cnt;
1469
1470         if ((coex_sta->low_priority_tx) > 1050 ||
1471             (coex_sta->low_priority_rx) > 1250)
1472             retry_count++;
1473
1474         result = 0;
1475         wait_count++;
1476         /* no retry in the last 2-second duration */
1477         if (retry_count == 0) {
1478             up++;
1479             dn--;
1480
1481             if (dn <= 0)
1482                 dn = 0;
1483
1484             if (up >= n) {
1485                 /* if retry count during continuous n*2 seconds
1486                  * is 0, enlarge WiFi duration
1487                  */
1488                 wait_count = 0;
1489                 n = 3;
1490                 up = 0;
1491                 dn = 0;
1492                 result = 1;
1493                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1494                     "[BTCoex], Increase wifi duration!!\n");
1495             }
1496         } else if (retry_count <= 3) {
1497             /* <=3 retry in the last 2-second duration */
1498             up--;
1499             dn++;
1500
1501             if (up <= 0)
1502                 up = 0;
1503
1504             if (dn == 2) {
1505                 /* if continuous 2 retry count(every 2 seconds)
1506                  * >0 and < 3, reduce WiFi duration
1507                  */
1508                 if (wait_count <= 2)
1509                     /* avoid loop between the two levels */
1510                     m++;
1511                 else
1512                     m = 1;
1513
1514                 if (m >= 20)
1515                     /* maximum of m = 20 ' will recheck if
1516                      * need to adjust wifi duration in
1517                      * maximum time interval 120 seconds
1518                      */
1519                     m = 20;
1520
1521                 n = 3 * m;
1522                 up = 0;
1523                 dn = 0;
1524                 wait_count = 0;
1525                 result = -1;
1526                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1527                     "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1528             }
1529         } else {
1530             /* retry count > 3, once retry count > 3, to reduce
1531              * WiFi duration
1532              */
1533             if (wait_count == 1)
1534                 /* to avoid loop between the two levels */
1535                 m++;
1536             else
1537                 m = 1;
1538
1539             if (m >= 20)
1540                 /* maximum of m = 20 ' will recheck if need to
1541                  * adjust wifi duration in maximum time interval
1542                  * 120 seconds
1543                  */
1544                 m = 20;
1545
1546             n = 3 * m;
1547             up = 0;
1548             dn = 0;
1549             wait_count = 0;
1550             result = -1;
1551             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1552                 "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1553         }
1554
1555         if (result == -1) {
1556             if (coex_dm->cur_ps_tdma == 1) {
1557                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1558                             true, 2);
1559                 coex_dm->ps_tdma_du_adj_type = 2;
1560             } else if (coex_dm->cur_ps_tdma == 2) {
1561                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1562                             true, 9);
1563                 coex_dm->ps_tdma_du_adj_type = 9;
1564             } else if (coex_dm->cur_ps_tdma == 9) {
1565                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1566                             true, 11);
1567                 coex_dm->ps_tdma_du_adj_type = 11;
1568             }
1569         } else if (result == 1) {
1570             if (coex_dm->cur_ps_tdma == 11) {
1571                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1572                             true, 9);
1573                 coex_dm->ps_tdma_du_adj_type = 9;
1574             } else if (coex_dm->cur_ps_tdma == 9) {
1575                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1576                             true, 2);
1577                 coex_dm->ps_tdma_du_adj_type = 2;
1578             } else if (coex_dm->cur_ps_tdma == 2) {
1579                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1580                             true, 1);
1581                 coex_dm->ps_tdma_du_adj_type = 1;
1582             }
1583         }
1584
1585         if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 &&
1586             coex_dm->cur_ps_tdma != 9 && coex_dm->cur_ps_tdma != 11) {
1587             /* recover to previous adjust type */
1588             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1589                         coex_dm->ps_tdma_du_adj_type);
1590         }
1591     }
1592 }
1593
1594 static void halbtc8723b1ant_ps_tdma_chk_pwr_save(struct btc_coexist *btcoexist,
1595                       bool new_ps_state)
1596 {
1597     u8 lps_mode = 0x0;
1598
1599     btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1600
1601     if (lps_mode) {
1602         /* already under LPS state */
1603         if (new_ps_state) {
1604             /* keep state under LPS, do nothing. */
1605         } else {
1606             /* will leave LPS state, turn off psTdma first */
1607             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1608                         false, 0);
1609         }
1610     } else {
1611         /* NO PS state */
1612         if (new_ps_state) {
1613             /* will enter LPS state, turn off psTdma first */
1614             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1615                         false, 0);
1616         } else {
1617             /* keep state under NO PS state, do nothing. */
1618         }
1619     }
1620 }
1621
1622 static void halbtc8723b1ant_power_save_state(struct btc_coexist *btcoexist,
1623                          u8 ps_type, u8 lps_val,
1624                          u8 rpwm_val)
1625 {
1626     bool low_pwr_disable = false;
1627
1628     switch (ps_type) {
1629     case BTC_PS_WIFI_NATIVE:
1630         /* recover to original 32k low power setting */
1631         low_pwr_disable = false;
1632         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1633                    &low_pwr_disable);
1634         btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1635         coex_sta->force_lps_on = false;
1636         break;
1637     case BTC_PS_LPS_ON:
1638         halbtc8723b1ant_ps_tdma_chk_pwr_save(btcoexist, true);
1639         halbtc8723b1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1640                      rpwm_val);
1641         /* when coex force to enter LPS, do not enter 32k low power */
1642         low_pwr_disable = true;
1643         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1644                    &low_pwr_disable);
1645         /* power save must executed before psTdma */
1646         btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1647         coex_sta->force_lps_on = true;
1648         break;
1649     case BTC_PS_LPS_OFF:
1650         halbtc8723b1ant_ps_tdma_chk_pwr_save(btcoexist, false);
1651         btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1652         coex_sta->force_lps_on = false;
1653         break;
1654     default:
1655         break;
1656     }
1657 }
1658
1659 static void halbtc8723b1ant_action_wifi_only(struct btc_coexist *btcoexist)
1660 {
1661     halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
1662     halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
1663     halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1664                      FORCE_EXEC, false, false);
1665 }
1666
1667 /* check if BT is disabled */
1668 static void halbtc8723b1ant_monitor_bt_enable_disable(struct btc_coexist
1669                               *btcoexist)
1670 {
1671     struct rtl_priv *rtlpriv = btcoexist->adapter;
1672     static u32 bt_disable_cnt;
1673     bool bt_active = true, bt_disabled = false;
1674
1675     if (coex_sta->high_priority_tx == 0 &&
1676         coex_sta->high_priority_rx == 0 && coex_sta->low_priority_tx == 0 &&
1677         coex_sta->low_priority_rx == 0)
1678         bt_active = false;
1679     if (coex_sta->high_priority_tx == 0xffff &&
1680         coex_sta->high_priority_rx == 0xffff &&
1681         coex_sta->low_priority_tx == 0xffff &&
1682         coex_sta->low_priority_rx == 0xffff)
1683         bt_active = false;
1684     if (bt_active) {
1685         bt_disable_cnt = 0;
1686         bt_disabled = false;
1687     } else {
1688         bt_disable_cnt++;
1689         if (bt_disable_cnt >= 2)
1690             bt_disabled = true;
1691     }
1692     if (coex_sta->bt_disabled != bt_disabled) {
1693         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1694             "[BTCoex], BT is from %s to %s!!\n",
1695             (coex_sta->bt_disabled ? "disabled" : "enabled"),
1696             (bt_disabled ? "disabled" : "enabled"));
1697
1698         coex_sta->bt_disabled = bt_disabled;
1699         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1700                    &bt_disabled);
1701         if (bt_disabled) {
1702             halbtc8723b1ant_action_wifi_only(btcoexist);
1703             btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1704                        NULL);
1705             btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
1706                        NULL);
1707         }
1708     }
1709 }
1710
1711 /*****************************************************
1712  *
1713  *  Non-Software Coex Mechanism start
1714  *
1715  *****************************************************/
1716
1717 static void halbtc8723b1ant_action_bt_whck_test(struct btc_coexist *btcoexist)
1718 {
1719     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
1720                      0x0);
1721
1722     halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1723     halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
1724                      false, false);
1725     halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1726 }
1727
1728 static void halbtc8723b1ant_action_wifi_multiport(struct btc_coexist *btcoexist)
1729 {
1730     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1731                      0x0, 0x0);
1732
1733     halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1734     halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
1735                      false, false);
1736     halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1737 }
1738
1739 static void halbtc8723b1ant_action_hs(struct btc_coexist *btcoexist)
1740 {
1741     halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1742     halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1743 }
1744
1745 static void halbtc8723b1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1746 {
1747     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1748     bool wifi_connected = false, ap_enable = false;
1749     bool wifi_busy = false, bt_busy = false;
1750
1751     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1752                &ap_enable);
1753     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1754                &wifi_connected);
1755     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1756     btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1757
1758     if (coex_sta->bt_abnormal_scan) {
1759         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
1760         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1761     } else if (!wifi_connected && !coex_sta->wifi_is_high_pri_task) {
1762         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1763                          0x0, 0x0);
1764         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1765         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1766                          NORMAL_EXEC, false, false);
1767         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1768     } else if (bt_link_info->sco_exist || bt_link_info->hid_exist ||
1769            bt_link_info->a2dp_exist) {
1770         /* SCO/HID/A2DP busy */
1771         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1772                          0x0, 0x0);
1773         if (coex_sta->c2h_bt_remote_name_req)
1774             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1775                         33);
1776         else
1777             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1778                         32);
1779
1780         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1781     } else if (bt_link_info->pan_exist || wifi_busy) {
1782         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1783                          0x0, 0x0);
1784         if (coex_sta->c2h_bt_remote_name_req)
1785             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1786                         33);
1787         else
1788             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1789                         32);
1790
1791         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1792     } else {
1793         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1794                          0x0, 0x0);
1795         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1796         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1797                          NORMAL_EXEC, false, false);
1798         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1799     }
1800 }
1801
1802 static void btc8723b1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
1803                           u8 wifi_status)
1804 {
1805     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1806     bool wifi_connected = false;
1807
1808     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1809                &wifi_connected);
1810
1811     /* tdma and coex table */
1812     if (bt_link_info->sco_exist) {
1813         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1814         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
1815     } else {
1816         /* HID */
1817         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1818         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
1819     }
1820 }
1821
1822 static void halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
1823                     struct btc_coexist *btcoexist,
1824                     u8 wifi_status)
1825 {
1826     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1827
1828     if ((coex_sta->low_priority_rx >= 950) && (!coex_sta->under_ips))
1829         bt_link_info->slave_role = true;
1830     else
1831         bt_link_info->slave_role = false;
1832
1833     if (bt_link_info->hid_only) { /* HID */
1834         btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, wifi_status);
1835         coex_dm->auto_tdma_adjust = false;
1836         return;
1837     } else if (bt_link_info->a2dp_only) { /* A2DP */
1838         if (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1839             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1840                         true, 32);
1841             halbtc8723b1ant_coex_table_with_type(btcoexist,
1842                                  NORMAL_EXEC, 4);
1843             coex_dm->auto_tdma_adjust = false;
1844         } else {
1845             btc8723b1ant_tdma_dur_adj_for_acl(btcoexist,
1846                               wifi_status);
1847             halbtc8723b1ant_coex_table_with_type(btcoexist,
1848                                  NORMAL_EXEC, 1);
1849             coex_dm->auto_tdma_adjust = true;
1850         }
1851     } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
1852            (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
1853             bt_link_info->pan_exist)) {
1854         /* A2DP + PAN(OPP,FTP), HID + A2DP + PAN(OPP,FTP) */
1855         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
1856         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1857         coex_dm->auto_tdma_adjust = false;
1858     } else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) {
1859         /* HID + A2DP */
1860         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1861         coex_dm->auto_tdma_adjust = false;
1862
1863         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1864     } else if (bt_link_info->pan_only ||
1865             (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
1866         /* PAN(OPP,FTP), HID + PAN(OPP,FTP) */
1867         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1868         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1869         coex_dm->auto_tdma_adjust = false;
1870     } else {
1871         /* BT no-profile busy (0x9) */
1872         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
1873         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1874         coex_dm->auto_tdma_adjust = false;
1875     }
1876 }
1877
1878 static void btc8723b1ant_action_wifi_not_conn(struct btc_coexist *btcoexist)
1879 {
1880     /* power save state */
1881     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1882                      0x0, 0x0);
1883
1884     /* tdma and coex table */
1885     halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
1886     halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
1887                      false, false);
1888     halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1889 }
1890
1891 static void
1892 btc8723b1ant_action_wifi_not_conn_scan(struct btc_coexist *btcoexist)
1893 {
1894     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1895
1896     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1897                      0x0, 0x0);
1898
1899     /* tdma and coex table */
1900     if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1901         if (bt_link_info->a2dp_exist) {
1902             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1903                         true, 32);
1904             halbtc8723b1ant_coex_table_with_type(btcoexist,
1905                                  NORMAL_EXEC, 4);
1906         } else if (bt_link_info->a2dp_exist) {
1907             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1908                         true, 22);
1909             halbtc8723b1ant_coex_table_with_type(btcoexist,
1910                                  NORMAL_EXEC, 4);
1911         } else {
1912             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1913                         true, 20);
1914             halbtc8723b1ant_coex_table_with_type(btcoexist,
1915                                  NORMAL_EXEC, 1);
1916         }
1917     } else if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
1918            coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY){
1919         btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
1920                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1921     } else {
1922         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1923         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1924                          NORMAL_EXEC, false, false);
1925         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1926     }
1927 }
1928
1929 static void
1930 btc8723b1ant_act_wifi_not_conn_asso_auth(struct btc_coexist *btcoexist)
1931 {
1932     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1933
1934     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1935                      0x0, 0x0);
1936
1937     /* tdma and coex table */
1938     if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
1939         (bt_link_info->a2dp_exist)) {
1940         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1941         halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
1942     } else if (bt_link_info->pan_exist) {
1943         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1944         halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
1945     } else {
1946         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1947         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1948                          NORMAL_EXEC, false, false);
1949         halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
1950     }
1951 }
1952
1953 static void btc8723b1ant_action_wifi_conn_scan(struct btc_coexist *btcoexist)
1954 {
1955     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1956
1957     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1958                      0x0, 0x0);
1959
1960     /* tdma and coex table */
1961     if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1962         if (bt_link_info->a2dp_exist) {
1963             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1964                         true, 32);
1965             halbtc8723b1ant_coex_table_with_type(btcoexist,
1966                                  NORMAL_EXEC, 4);
1967         } else if (bt_link_info->a2dp_exist &&
1968                bt_link_info->pan_exist) {
1969             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1970                         true, 22);
1971             halbtc8723b1ant_coex_table_with_type(btcoexist,
1972                                  NORMAL_EXEC, 4);
1973         } else {
1974             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1975                         true, 20);
1976             halbtc8723b1ant_coex_table_with_type(btcoexist,
1977                                  NORMAL_EXEC, 4);
1978         }
1979     } else if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
1980            coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) {
1981         btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
1982                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1983     } else {
1984         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1985         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1986                          NORMAL_EXEC, false, false);
1987         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1988     }
1989 }
1990
1991 static void halbtc8723b1ant_action_wifi_connected_special_packet(
1992                         struct btc_coexist *btcoexist)
1993 {
1994     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1995     bool wifi_busy = false;
1996
1997     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1998
1999     /* no special packet process for both WiFi and BT very busy */
2000     if ((wifi_busy) &&
2001         ((bt_link_info->pan_exist) || (coex_sta->num_of_profile >= 2)))
2002         return;
2003
2004     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2005                      0x0, 0x0);
2006
2007     /* tdma and coex table */
2008     if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
2009         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2010         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2011     } else if (bt_link_info->a2dp_exist) {
2012         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2013         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2014     } else if (bt_link_info->pan_exist) {
2015         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
2016         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2017     } else {
2018         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2019         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2020                          NORMAL_EXEC, false, false);
2021         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2022     }
2023 }
2024
2025 static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist *btcoexist)
2026 {
2027     struct rtl_priv *rtlpriv = btcoexist->adapter;
2028     bool wifi_busy = false;
2029     bool scan = false, link = false, roam = false;
2030     bool under_4way = false, ap_enable = false;
2031
2032     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2033         "[BTCoex], CoexForWifiConnect()===>\n");
2034
2035     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
2036                &under_4way);
2037     if (under_4way) {
2038         halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist);
2039         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2040             "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
2041         return;
2042     }
2043
2044     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2045     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2046     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2047
2048     if (scan || link || roam) {
2049         if (scan)
2050             btc8723b1ant_action_wifi_conn_scan(btcoexist);
2051         else
2052             halbtc8723b1ant_action_wifi_connected_special_packet(
2053                                      btcoexist);
2054         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2055             "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
2056         return;
2057     }
2058
2059     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
2060                &ap_enable);
2061     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2062     /* power save state */
2063     if (!ap_enable &&
2064         coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY &&
2065         !btcoexist->bt_link_info.hid_only) {
2066         if (btcoexist->bt_link_info.a2dp_only) {
2067             if (!wifi_busy) {
2068                 halbtc8723b1ant_power_save_state(btcoexist,
2069                              BTC_PS_WIFI_NATIVE,
2070                              0x0, 0x0);
2071             } else { /* busy */
2072                 if (coex_sta->scan_ap_num >=
2073                     BT_8723B_1ANT_WIFI_NOISY_THRESH)
2074                     /* no force LPS, no PS-TDMA,
2075                      * use pure TDMA
2076                      */
2077                     halbtc8723b1ant_power_save_state(
2078                         btcoexist, BTC_PS_WIFI_NATIVE,
2079                         0x0, 0x0);
2080                 else
2081                     halbtc8723b1ant_power_save_state(
2082                         btcoexist, BTC_PS_LPS_ON, 0x50,
2083                         0x4);
2084             }
2085         } else if ((!coex_sta->pan_exist) && (!coex_sta->a2dp_exist) &&
2086                (!coex_sta->hid_exist))
2087             halbtc8723b1ant_power_save_state(
2088                 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2089         else
2090             halbtc8723b1ant_power_save_state(btcoexist,
2091                              BTC_PS_LPS_ON,
2092                              0x50, 0x4);
2093     } else {
2094         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2095                          0x0, 0x0);
2096     }
2097     /* tdma and coex table */
2098     if (!wifi_busy) {
2099         if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
2100             halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2101                 btcoexist,
2102                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
2103         } else if (coex_dm->bt_status ==
2104                 BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2105                coex_dm->bt_status ==
2106                 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) {
2107             btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
2108                      BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
2109         } else {
2110             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2111                         false, 8);
2112             halbtc8723b1ant_set_ant_path(btcoexist,
2113                              BTC_ANT_PATH_PTA,
2114                              NORMAL_EXEC, false, false);
2115             halbtc8723b1ant_coex_table_with_type(btcoexist,
2116                                  NORMAL_EXEC, 2);
2117         }
2118     } else {
2119         if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
2120             halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2121                 btcoexist,
2122                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
2123         } else if (coex_dm->bt_status ==
2124                 BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2125                coex_dm->bt_status ==
2126                 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) {
2127             btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist,
2128                     BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
2129         } else {
2130             halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2131                         true, 32);
2132             halbtc8723b1ant_set_ant_path(btcoexist,
2133                              BTC_ANT_PATH_PTA,
2134                              NORMAL_EXEC, false, false);
2135             halbtc8723b1ant_coex_table_with_type(btcoexist,
2136                                  NORMAL_EXEC, 4);
2137         }
2138     }
2139 }
2140
2141 static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
2142 {
2143     struct rtl_priv *rtlpriv = btcoexist->adapter;
2144     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2145     bool wifi_connected = false, bt_hs_on = false, wifi_busy = false;
2146     bool increase_scan_dev_num = false;
2147     bool bt_ctrl_agg_buf_size = false;
2148     bool miracast_plus_bt = false;
2149     u8 agg_buf_size = 5;
2150     u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2151     u32 wifi_link_status = 0;
2152     u32 num_of_wifi_link = 0;
2153     u32 wifi_bw;
2154
2155     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2156         "[BTCoex], RunCoexistMechanism()===>\n");
2157
2158     if (btcoexist->manual_control) {
2159         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2160             "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
2161         return;
2162     }
2163
2164     if (btcoexist->stop_coex_dm) {
2165         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2166             "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
2167         return;
2168     }
2169
2170     if (coex_sta->under_ips) {
2171         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2172             "[BTCoex], wifi is under IPS !!!\n");
2173         return;
2174     }
2175
2176     if (coex_sta->bt_whck_test) {
2177         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2178             "[BTCoex], wifi is under IPS !!!\n");
2179         halbtc8723b1ant_action_bt_whck_test(btcoexist);
2180         return;
2181     }
2182
2183     if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY ||
2184         coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY ||
2185         coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
2186         increase_scan_dev_num = true;
2187
2188     btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
2189                &increase_scan_dev_num);
2190     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2191                &wifi_connected);
2192     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2193
2194     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2195                &wifi_link_status);
2196     num_of_wifi_link = wifi_link_status >> 16;
2197
2198     if (num_of_wifi_link >= 2 ||
2199         wifi_link_status & WIFI_P2P_GO_CONNECTED) {
2200         if (bt_link_info->bt_link_exist) {
2201             halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1,
2202                            0, 1);
2203             miracast_plus_bt = true;
2204         } else {
2205             halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0,
2206                            0, 0);
2207             miracast_plus_bt = false;
2208         }
2209         btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
2210                    &miracast_plus_bt);
2211         halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2212                        bt_ctrl_agg_buf_size, agg_buf_size);
2213
2214         if ((bt_link_info->a2dp_exist || wifi_busy) &&
2215             (coex_sta->c2h_bt_inquiry_page))
2216             halbtc8723b1ant_action_bt_inquiry(btcoexist);
2217         else
2218             halbtc8723b1ant_action_wifi_multiport(btcoexist);
2219
2220         return;
2221     }
2222
2223     miracast_plus_bt = false;
2224     btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
2225                &miracast_plus_bt);
2226     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2227
2228     if (bt_link_info->bt_link_exist && wifi_connected) {
2229         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 0, 1);
2230
2231         btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2232
2233         if (iot_peer != BTC_IOT_PEER_CISCO &&
2234             iot_peer != BTC_IOT_PEER_BROADCOM) {
2235             bool sco_exist = bt_link_info->sco_exist;
2236
2237             halbtc8723b1ant_limited_rx(btcoexist,
2238                            NORMAL_EXEC, sco_exist,
2239                            false, 0x5);
2240         } else {
2241             if (bt_link_info->sco_exist) {
2242                 halbtc8723b1ant_limited_rx(btcoexist,
2243                                NORMAL_EXEC, true,
2244                                false, 0x5);
2245             } else {
2246                 if (wifi_bw == BTC_WIFI_BW_HT40)
2247                     halbtc8723b1ant_limited_rx(
2248                         btcoexist, NORMAL_EXEC, false,
2249                         true, 0x10);
2250                 else
2251                     halbtc8723b1ant_limited_rx(
2252                         btcoexist, NORMAL_EXEC, false,
2253                         true, 0x8);
2254             }
2255         }
2256
2257         halbtc8723b1ant_sw_mechanism(btcoexist, true);
2258     } else {
2259         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2260
2261         halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2262                        0x5);
2263
2264         halbtc8723b1ant_sw_mechanism(btcoexist, false);
2265     }
2266     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2267
2268     if (coex_sta->c2h_bt_inquiry_page) {
2269         halbtc8723b1ant_action_bt_inquiry(btcoexist);
2270         return;
2271     } else if (bt_hs_on) {
2272         halbtc8723b1ant_action_hs(btcoexist);
2273         return;
2274     }
2275
2276     if (!wifi_connected) {
2277         bool scan = false, link = false, roam = false;
2278
2279         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2280             "[BTCoex], wifi is non connected-idle !!!\n");
2281
2282         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2283         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2284         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2285
2286         if (scan || link || roam) {
2287             if (scan)
2288                 btc8723b1ant_action_wifi_not_conn_scan(
2289                                      btcoexist);
2290             else
2291                 btc8723b1ant_act_wifi_not_conn_asso_auth(
2292                                      btcoexist);
2293         } else {
2294             btc8723b1ant_action_wifi_not_conn(btcoexist);
2295         }
2296     } else { /* wifi LPS/Busy */
2297         halbtc8723b1ant_action_wifi_connected(btcoexist);
2298     }
2299 }
2300
2301 /* force coex mechanism to reset */
2302 static void halbtc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist)
2303 {
2304     /* sw all off */
2305     halbtc8723b1ant_sw_mechanism(btcoexist, false);
2306
2307     coex_sta->pop_event_cnt = 0;
2308 }
2309
2310 static void halbtc8723b1ant_init_hw_config(struct btc_coexist *btcoexist,
2311                        bool backup, bool wifi_only)
2312 {
2313     struct rtl_priv *rtlpriv = btcoexist->adapter;
2314     u32 u32tmp = 0;
2315     u8 u8tmpa = 0, u8tmpb = 0;
2316
2317     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2318         "[BTCoex], 1Ant Init HW Config!!\n");
2319
2320     /* 0xf0[15:12] --> Chip Cut information */
2321     coex_sta->cut_version =
2322         (btcoexist->btc_read_1byte(btcoexist, 0xf1) & 0xf0) >> 4;
2323     /* enable TBTT interrupt */
2324     btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8, 0x1);
2325
2326     /* 0x790[5:0] = 0x5 */
2327     btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
2328
2329     /* Enable counter statistics */
2330     btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
2331     btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
2332
2333     halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2334
2335     /* Antenna config */
2336     if (wifi_only)
2337         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
2338                          FORCE_EXEC, true, false);
2339     else
2340         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2341                          FORCE_EXEC, true, false);
2342
2343     /* PTA parameter */
2344     halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2345
2346     u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
2347     u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
2348     u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
2349
2350     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2351         "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
2352         u32tmp, u8tmpa, u8tmpb);
2353 }
2354
2355 /**************************************************************
2356  * extern function start with ex_btc8723b1ant_
2357  **************************************************************/
2358 void ex_btc8723b1ant_power_on_setting(struct btc_coexist *btcoexist)
2359 {
2360     struct rtl_priv *rtlpriv = btcoexist->adapter;
2361     struct btc_board_info *board_info = &btcoexist->board_info;
2362     u8 u8tmp = 0x0;
2363     u16 u16tmp = 0x0;
2364     u32 value;
2365
2366     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2367         "xxxxxxxxxxxxxxxx Execute 8723b 1-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
2368
2369     btcoexist->stop_coex_dm = true;
2370
2371     btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
2372
2373     /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
2374     u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
2375     btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT0 | BIT1);
2376
2377     /* set GRAN_BT = 1 */
2378     btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
2379     /* set WLAN_ACT = 0 */
2380     btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
2381
2382     /* S0 or S1 setting and Local register setting(By the setting fw can get
2383      * ant number, S0/S1, ... info)
2384      *
2385      * Local setting bit define
2386      *  BIT0: "0" for no antenna inverse; "1" for antenna inverse
2387      *  BIT1: "0" for internal switch; "1" for external switch
2388      *  BIT2: "0" for one antenna; "1" for two antenna
2389      * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
2390      * BIT2 = 0
2391      */
2392     if (btcoexist->chip_interface == BTC_INTF_USB) {
2393         /* fixed at S0 for USB interface */
2394         btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
2395
2396         u8tmp |= 0x1; /* antenna inverse */
2397         btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
2398
2399         board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
2400     } else {
2401         /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
2402         if (board_info->single_ant_path == 0) {
2403             /* set to S1 */
2404             btcoexist->btc_write_4byte(btcoexist, 0x948, 0x280);
2405             board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
2406             value = 1;
2407         } else if (board_info->single_ant_path == 1) {
2408             /* set to S0 */
2409             btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
2410             u8tmp |= 0x1; /* antenna inverse */
2411             board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
2412             value = 0;
2413         }
2414
2415         btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
2416                    &value);
2417
2418         if (btcoexist->chip_interface == BTC_INTF_PCI)
2419             btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
2420                                  u8tmp);
2421         else if (btcoexist->chip_interface == BTC_INTF_SDIO)
2422             btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
2423                                  u8tmp);
2424     }
2425 }
2426
2427
2428 void ex_btc8723b1ant_init_hwconfig(struct btc_coexist *btcoexist,
2429                    bool wifi_only)
2430 {
2431     halbtc8723b1ant_init_hw_config(btcoexist, true, wifi_only);
2432     btcoexist->stop_coex_dm = false;
2433 }
2434
2435 void ex_btc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist)
2436 {
2437     struct rtl_priv *rtlpriv = btcoexist->adapter;
2438
2439     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2440         "[BTCoex], Coex Mechanism Init!!\n");
2441
2442     btcoexist->stop_coex_dm = false;
2443
2444     halbtc8723b1ant_init_coex_dm(btcoexist);
2445
2446     halbtc8723b1ant_query_bt_info(btcoexist);
2447 }
2448
2449 void ex_btc8723b1ant_display_coex_info(struct btc_coexist *btcoexist,
2450                        struct seq_file *m)
2451 {
2452     struct btc_board_info *board_info = &btcoexist->board_info;
2453     struct btc_stack_info *stack_info = &btcoexist->stack_info;
2454     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2455     u8 u8tmp[4], i, bt_info_ext, pstdmacase = 0;
2456     u16 u16tmp[4];
2457     u32 u32tmp[4];
2458     bool roam = false, scan = false;
2459     bool link = false, wifi_under_5g = false;
2460     bool bt_hs_on = false, wifi_busy = false;
2461     s32 wifi_rssi = 0, bt_hs_rssi = 0;
2462     u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck, wifi_link_status;
2463     u8 wifi_dot11_chnl, wifi_hs_chnl;
2464     u32 fw_ver = 0, bt_patch_ver = 0;
2465
2466     seq_puts(m, "\n ============[BT Coexist info]============");
2467
2468     if (btcoexist->manual_control) {
2469         seq_puts(m, "\n ============[Under Manual Control]==========");
2470         seq_puts(m, "\n ==========================================");
2471     }
2472     if (btcoexist->stop_coex_dm) {
2473         seq_puts(m, "\n ============[Coex is STOPPED]============");
2474         seq_puts(m, "\n ==========================================");
2475     }
2476
2477     seq_printf(m, "\n %-35s = %d/ %d/ %d",
2478            "Ant PG Num/ Ant Mech/ Ant Pos:",
2479            board_info->pg_ant_num, board_info->btdm_ant_num,
2480            board_info->btdm_ant_pos);
2481
2482     seq_printf(m, "\n %-35s = %s / %d",
2483            "BT stack/ hci ext ver",
2484            ((stack_info->profile_notified) ? "Yes" : "No"),
2485            stack_info->hci_version);
2486
2487     btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
2488     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2489     seq_printf(m, "\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2490            "CoexVer/ FwVer/ PatchVer",
2491            glcoex_ver_date_8723b_1ant, glcoex_ver_8723b_1ant,
2492            fw_ver, bt_patch_ver, bt_patch_ver);
2493
2494     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2495     btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
2496                &wifi_dot11_chnl);
2497     btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
2498     seq_printf(m, "\n %-35s = %d / %d(%d)",
2499            "Dot11 channel / HsChnl(HsMode)",
2500            wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
2501
2502     seq_printf(m, "\n %-35s = %3ph ",
2503            "H2C Wifi inform bt chnl Info",
2504            coex_dm->wifi_chnl_info);
2505
2506     btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
2507     btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
2508     seq_printf(m, "\n %-35s = %d/ %d",
2509            "Wifi rssi/ HS rssi", wifi_rssi, bt_hs_rssi);
2510
2511     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2512     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2513     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2514     seq_printf(m, "\n %-35s = %d/ %d/ %d ",
2515            "Wifi link/ roam/ scan", link, roam, scan);
2516
2517     btcoexist->btc_get(btcoexist , BTC_GET_BL_WIFI_UNDER_5G,
2518                &wifi_under_5g);
2519     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2520     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2521     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
2522                &wifi_traffic_dir);
2523
2524     seq_printf(m, "\n %-35s = %s / %s/ %s ",
2525            "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
2526            ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
2527             ((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20")),
2528             ((!wifi_busy) ? "idle" :
2529              ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
2530              "uplink" : "downlink")));
2531
2532     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2533                &wifi_link_status);
2534     seq_printf(m, "\n %-35s = %d/ %d/ %d/ %d/ %d",
2535            "sta/vwifi/hs/p2pGo/p2pGc",
2536            ((wifi_link_status & WIFI_STA_CONNECTED) ? 1 : 0),
2537            ((wifi_link_status & WIFI_AP_CONNECTED) ? 1 : 0),
2538            ((wifi_link_status & WIFI_HS_CONNECTED) ? 1 : 0),
2539            ((wifi_link_status & WIFI_P2P_GO_CONNECTED) ? 1 : 0),
2540            ((wifi_link_status & WIFI_P2P_GC_CONNECTED) ? 1 : 0));
2541
2542     seq_printf(m, "\n %-35s = [%s/ %d/ %d] ",
2543            "BT [status/ rssi/ retryCnt]",
2544            ((coex_sta->bt_disabled) ? ("disabled") :
2545             ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") :
2546              ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2547                coex_dm->bt_status) ?
2548               "non-connected idle" :
2549               ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2550             coex_dm->bt_status) ?
2551                "connected-idle" : "busy")))),
2552                coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
2553
2554     seq_printf(m, "\n %-35s = %d / %d / %d / %d",
2555            "SCO/HID/PAN/A2DP", bt_link_info->sco_exist,
2556            bt_link_info->hid_exist, bt_link_info->pan_exist,
2557            bt_link_info->a2dp_exist);
2558     btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO, m);
2559
2560     bt_info_ext = coex_sta->bt_info_ext;
2561     seq_printf(m, "\n %-35s = %s",
2562            "BT Info A2DP rate",
2563            (bt_info_ext & BIT0) ? "Basic rate" : "EDR rate");
2564
2565     for (i = 0; i < BT_INFO_SRC_8723B_1ANT_MAX; i++) {
2566         if (coex_sta->bt_info_c2h_cnt[i]) {
2567             seq_printf(m, "\n %-35s = %7ph(%d)",
2568                    glbt_info_src_8723b_1ant[i],
2569                    coex_sta->bt_info_c2h[i],
2570                    coex_sta->bt_info_c2h_cnt[i]);
2571         }
2572     }
2573     seq_printf(m, "\n %-35s = %s/%s, (0x%x/0x%x)",
2574            "PS state, IPS/LPS, (lps/rpwm)",
2575            ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
2576            ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")),
2577            btcoexist->bt_info.lps_val,
2578            btcoexist->bt_info.rpwm_val);
2579     btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
2580
2581     if (!btcoexist->manual_control) {
2582         /* Sw mechanism */
2583         seq_printf(m, "\n %-35s",
2584                "============[Sw mechanism]============");
2585
2586         seq_printf(m, "\n %-35s = %d/",
2587                "SM[LowPenaltyRA]", coex_dm->cur_low_penalty_ra);
2588
2589         seq_printf(m, "\n %-35s = %s/ %s/ %d ",
2590                "DelBA/ BtCtrlAgg/ AggSize",
2591                (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"),
2592                (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"),
2593                btcoexist->bt_info.agg_buf_size);
2594
2595         seq_printf(m, "\n %-35s = 0x%x ",
2596                "Rate Mask", btcoexist->bt_info.ra_mask);
2597
2598         /* Fw mechanism */
2599         seq_printf(m, "\n %-35s",
2600                "============[Fw mechanism]============");
2601
2602         pstdmacase = coex_dm->cur_ps_tdma;
2603         seq_printf(m, "\n %-35s = %5ph case-%d (auto:%d)",
2604                "PS TDMA", coex_dm->ps_tdma_para,
2605                pstdmacase, coex_dm->auto_tdma_adjust);
2606
2607         seq_printf(m, "\n %-35s = %d ",
2608                "IgnWlanAct", coex_dm->cur_ignore_wlan_act);
2609
2610         seq_printf(m, "\n %-35s = 0x%x ",
2611                "Latest error condition(should be 0)",
2612                coex_dm->error_condition);
2613     }
2614
2615     seq_printf(m, "\n %-35s = %d",
2616            "Coex Table Type", coex_sta->coex_table_type);
2617
2618     /* Hw setting */
2619     seq_printf(m, "\n %-35s",
2620            "============[Hw setting]============");
2621
2622     seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2623            "backup ARFR1/ARFR2/RL/AMaxTime", coex_dm->backup_arfr_cnt1,
2624            coex_dm->backup_arfr_cnt2, coex_dm->backup_retry_limit,
2625            coex_dm->backup_ampdu_max_time);
2626
2627     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
2628     u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
2629     u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
2630     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
2631     seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2632            "0x430/0x434/0x42a/0x456",
2633            u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
2634
2635     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
2636     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
2637     u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x880);
2638     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2639            "0x778/0x6cc/0x880[29:25]", u8tmp[0], u32tmp[0],
2640            (u32tmp[1] & 0x3e000000) >> 25);
2641
2642     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
2643     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
2644     u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
2645     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2646            "0x948/ 0x67[5] / 0x765",
2647            u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]);
2648
2649     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
2650     u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
2651     u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
2652     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2653            "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
2654            u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
2655
2656     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
2657     u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
2658     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
2659     u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
2660     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2661            "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
2662            ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
2663             ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
2664
2665     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
2666     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
2667     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
2668            "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
2669
2670     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
2671     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
2672     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
2673            "0xc50(dig)/0x49c(null-drop)", u32tmp[0] & 0xff, u8tmp[0]);
2674
2675     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
2676     u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
2677     u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
2678     u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
2679
2680     u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
2681     u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
2682
2683     fa_ofdm = ((u32tmp[0] & 0xffff0000) >> 16) +
2684           ((u32tmp[1] & 0xffff0000) >> 16) +
2685            (u32tmp[1] & 0xffff) +
2686            (u32tmp[2] & 0xffff) +
2687           ((u32tmp[3] & 0xffff0000) >> 16) +
2688            (u32tmp[3] & 0xffff);
2689     fa_cck = (u8tmp[0] << 8) + u8tmp[1];
2690
2691     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2692            "OFDM-CCA/OFDM-FA/CCK-FA",
2693          u32tmp[0] & 0xffff, fa_ofdm, fa_cck);
2694
2695     u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
2696     u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
2697     u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
2698     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2699            "0x6c0/0x6c4/0x6c8(coexTable)",
2700            u32tmp[0], u32tmp[1], u32tmp[2]);
2701
2702     seq_printf(m, "\n %-35s = %d/ %d",
2703            "0x770(high-pri rx/tx)", coex_sta->high_priority_rx,
2704            coex_sta->high_priority_tx);
2705     seq_printf(m, "\n %-35s = %d/ %d",
2706            "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
2707            coex_sta->low_priority_tx);
2708     if (btcoexist->auto_report_1ant)
2709         halbtc8723b1ant_monitor_bt_ctr(btcoexist);
2710     btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
2711 }
2712
2713 void ex_btc8723b1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
2714 {
2715     struct rtl_priv *rtlpriv = btcoexist->adapter;
2716
2717     if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2718         return;
2719
2720     if (BTC_IPS_ENTER == type) {
2721         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2722             "[BTCoex], IPS ENTER notify\n");
2723         coex_sta->under_ips = true;
2724
2725         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2726                          FORCE_EXEC, false, true);
2727         /* set PTA control */
2728         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2729         halbtc8723b1ant_coex_table_with_type(btcoexist,
2730                              NORMAL_EXEC, 0);
2731     } else if (BTC_IPS_LEAVE == type) {
2732         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2733             "[BTCoex], IPS LEAVE notify\n");
2734         coex_sta->under_ips = false;
2735
2736         halbtc8723b1ant_init_hw_config(btcoexist, false, false);
2737         halbtc8723b1ant_init_coex_dm(btcoexist);
2738         halbtc8723b1ant_query_bt_info(btcoexist);
2739     }
2740 }
2741
2742 void ex_btc8723b1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
2743 {
2744     struct rtl_priv *rtlpriv = btcoexist->adapter;
2745
2746     if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2747         return;
2748
2749     if (BTC_LPS_ENABLE == type) {
2750         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2751             "[BTCoex], LPS ENABLE notify\n");
2752         coex_sta->under_lps = true;
2753     } else if (BTC_LPS_DISABLE == type) {
2754         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2755             "[BTCoex], LPS DISABLE notify\n");
2756         coex_sta->under_lps = false;
2757     }
2758 }
2759
2760 void ex_btc8723b1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
2761 {
2762     struct rtl_priv *rtlpriv = btcoexist->adapter;
2763     bool wifi_connected = false, bt_hs_on = false;
2764     u8 u8tmpa, u8tmpb;
2765     u32 u32tmp;
2766     u32 wifi_link_status = 0;
2767     u32 num_of_wifi_link = 0;
2768     bool bt_ctrl_agg_buf_size = false;
2769     u8 agg_buf_size = 5;
2770
2771     if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2772         return;
2773
2774     if (type == BTC_SCAN_START) {
2775         coex_sta->wifi_is_high_pri_task = true;
2776         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2777             "[BTCoex], SCAN START notify\n");
2778         /* Force antenna setup for no scan result issue */
2779         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2780         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2781                          FORCE_EXEC, false, false);
2782         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
2783         u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
2784         u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
2785
2786         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2787             "[BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
2788             u32tmp, u8tmpa, u8tmpb);
2789     } else {
2790         coex_sta->wifi_is_high_pri_task = false;
2791         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2792             "[BTCoex], SCAN FINISH notify\n");
2793
2794         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2795                    &coex_sta->scan_ap_num);
2796     }
2797
2798     if (coex_sta->bt_disabled)
2799         return;
2800
2801     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2802     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2803                &wifi_connected);
2804
2805     halbtc8723b1ant_query_bt_info(btcoexist);
2806
2807     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2808                &wifi_link_status);
2809     num_of_wifi_link = wifi_link_status >> 16;
2810     if (num_of_wifi_link >= 2) {
2811         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2812         halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2813                        bt_ctrl_agg_buf_size, agg_buf_size);
2814         halbtc8723b1ant_action_wifi_multiport(btcoexist);
2815         return;
2816     }
2817
2818     if (coex_sta->c2h_bt_inquiry_page) {
2819         halbtc8723b1ant_action_bt_inquiry(btcoexist);
2820         return;
2821     } else if (bt_hs_on) {
2822         halbtc8723b1ant_action_hs(btcoexist);
2823         return;
2824     }
2825
2826     if (BTC_SCAN_START == type) {
2827         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2828             "[BTCoex], SCAN START notify\n");
2829         if (!wifi_connected)
2830             /* non-connected scan */
2831             btc8723b1ant_action_wifi_not_conn_scan(btcoexist);
2832         else
2833             /* wifi is connected */
2834             btc8723b1ant_action_wifi_conn_scan(btcoexist);
2835     } else if (BTC_SCAN_FINISH == type) {
2836         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2837             "[BTCoex], SCAN FINISH notify\n");
2838         if (!wifi_connected)
2839             /* non-connected scan */
2840             btc8723b1ant_action_wifi_not_conn(btcoexist);
2841         else
2842             halbtc8723b1ant_action_wifi_connected(btcoexist);
2843     }
2844 }
2845
2846 void ex_btc8723b1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
2847 {
2848     struct rtl_priv *rtlpriv = btcoexist->adapter;
2849     bool wifi_connected = false, bt_hs_on = false;
2850     u32 wifi_link_status = 0;
2851     u32 num_of_wifi_link = 0;
2852     bool bt_ctrl_agg_buf_size = false, under_4way = false;
2853     u8 agg_buf_size = 5;
2854
2855     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
2856                &under_4way);
2857
2858     if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2859         coex_sta->bt_disabled)
2860         return;
2861
2862     if (type == BTC_ASSOCIATE_START) {
2863         coex_sta->wifi_is_high_pri_task = true;
2864
2865         /* Force antenna setup for no scan result issue */
2866         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2867         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2868                          FORCE_EXEC, false, false);
2869         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2870             "[BTCoex], CONNECT START notify\n");
2871         coex_dm->arp_cnt = 0;
2872     } else {
2873         coex_sta->wifi_is_high_pri_task = false;
2874         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2875             "[BTCoex], CONNECT FINISH notify\n");
2876     }
2877
2878     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2879                &wifi_link_status);
2880     num_of_wifi_link = wifi_link_status>>16;
2881     if (num_of_wifi_link >= 2) {
2882         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2883         halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2884                        bt_ctrl_agg_buf_size, agg_buf_size);
2885         halbtc8723b1ant_action_wifi_multiport(btcoexist);
2886         return;
2887     }
2888
2889     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2890     if (coex_sta->c2h_bt_inquiry_page) {
2891         halbtc8723b1ant_action_bt_inquiry(btcoexist);
2892         return;
2893     } else if (bt_hs_on) {
2894         halbtc8723b1ant_action_hs(btcoexist);
2895         return;
2896     }
2897
2898     if (BTC_ASSOCIATE_START == type) {
2899         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2900             "[BTCoex], CONNECT START notify\n");
2901         btc8723b1ant_act_wifi_not_conn_asso_auth(btcoexist);
2902     } else if (BTC_ASSOCIATE_FINISH == type) {
2903         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2904             "[BTCoex], CONNECT FINISH notify\n");
2905
2906         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2907                    &wifi_connected);
2908         if (!wifi_connected)
2909             /* non-connected scan */
2910             btc8723b1ant_action_wifi_not_conn(btcoexist);
2911         else
2912             halbtc8723b1ant_action_wifi_connected(btcoexist);
2913     }
2914 }
2915
2916 void ex_btc8723b1ant_media_status_notify(struct btc_coexist *btcoexist,
2917                      u8 type)
2918 {
2919     struct rtl_priv *rtlpriv = btcoexist->adapter;
2920     u8 h2c_parameter[3] = {0};
2921     u32 wifi_bw;
2922     u8 wifi_central_chnl;
2923     bool wifi_under_b_mode = false;
2924
2925     if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2926         coex_sta->bt_disabled)
2927         return;
2928
2929     if (type == BTC_MEDIA_CONNECT) {
2930         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2931             "[BTCoex], MEDIA connect notify\n");
2932         /* Force antenna setup for no scan result issue */
2933         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2934         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2935                          FORCE_EXEC, false, false);
2936         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
2937                    &wifi_under_b_mode);
2938
2939         /* Set CCK Tx/Rx high Pri except 11b mode */
2940         if (wifi_under_b_mode) {
2941             btcoexist->btc_write_1byte(btcoexist, 0x6cd,
2942                            0x00); /* CCK Tx */
2943             btcoexist->btc_write_1byte(btcoexist, 0x6cf,
2944                            0x00); /* CCK Rx */
2945         } else {
2946             btcoexist->btc_write_1byte(btcoexist, 0x6cd,
2947                            0x00); /* CCK Tx */
2948             btcoexist->btc_write_1byte(btcoexist, 0x6cf,
2949                            0x10); /* CCK Rx */
2950         }
2951
2952         coex_dm->backup_arfr_cnt1 =
2953             btcoexist->btc_read_4byte(btcoexist, 0x430);
2954         coex_dm->backup_arfr_cnt2 =
2955             btcoexist->btc_read_4byte(btcoexist, 0x434);
2956         coex_dm->backup_retry_limit =
2957             btcoexist->btc_read_2byte(btcoexist, 0x42a);
2958         coex_dm->backup_ampdu_max_time =
2959             btcoexist->btc_read_1byte(btcoexist, 0x456);
2960     } else {
2961         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2962             "[BTCoex], MEDIA disconnect notify\n");
2963         coex_dm->arp_cnt = 0;
2964
2965         btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
2966         btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
2967
2968         coex_sta->cck_ever_lock = false;
2969     }
2970
2971     /* only 2.4G we need to inform bt the chnl mask */
2972     btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
2973                &wifi_central_chnl);
2974
2975     if (type == BTC_MEDIA_CONNECT && wifi_central_chnl <= 14) {
2976         h2c_parameter[0] = 0x0;
2977         h2c_parameter[1] = wifi_central_chnl;
2978         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2979         if (BTC_WIFI_BW_HT40 == wifi_bw)
2980             h2c_parameter[2] = 0x30;
2981         else
2982             h2c_parameter[2] = 0x20;
2983     }
2984
2985     coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
2986     coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
2987     coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
2988
2989     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2990         "[BTCoex], FW write 0x66 = 0x%x\n",
2991         h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
2992         h2c_parameter[2]);
2993
2994     btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
2995 }
2996
2997 void ex_btc8723b1ant_special_packet_notify(struct btc_coexist *btcoexist,
2998                        u8 type)
2999 {
3000     struct rtl_priv *rtlpriv = btcoexist->adapter;
3001     bool bt_hs_on = false;
3002     u32 wifi_link_status = 0;
3003     u32 num_of_wifi_link = 0;
3004     bool bt_ctrl_agg_buf_size = false, under_4way = false;
3005     u8 agg_buf_size = 5;
3006
3007     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3008                &under_4way);
3009
3010     if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
3011         coex_sta->bt_disabled)
3012         return;
3013
3014     if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
3015         type == BTC_PACKET_ARP) {
3016         if (type == BTC_PACKET_ARP) {
3017             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3018                 "[BTCoex], special Packet ARP notify\n");
3019
3020             coex_dm->arp_cnt++;
3021             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3022                 "[BTCoex], ARP Packet Count = %d\n",
3023                  coex_dm->arp_cnt);
3024
3025             if ((coex_dm->arp_cnt >= 10) && (!under_4way))
3026                 /* if APR PKT > 10 after connect, do not go to
3027                  * ActionWifiConnectedSpecificPacket(btcoexist)
3028                  */
3029                 coex_sta->wifi_is_high_pri_task = false;
3030             else
3031                 coex_sta->wifi_is_high_pri_task = true;
3032         } else {
3033             coex_sta->wifi_is_high_pri_task = true;
3034             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3035                 "[BTCoex], special Packet DHCP or EAPOL notify\n");
3036         }
3037     } else {
3038         coex_sta->wifi_is_high_pri_task = false;
3039         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3040             "[BTCoex], special Packet [Type = %d] notify\n",
3041              type);
3042     }
3043
3044     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3045         &wifi_link_status);
3046     num_of_wifi_link = wifi_link_status >> 16;
3047     if (num_of_wifi_link >= 2) {
3048         halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3049         halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3050                        bt_ctrl_agg_buf_size, agg_buf_size);
3051         halbtc8723b1ant_action_wifi_multiport(btcoexist);
3052         return;
3053     }
3054
3055     coex_sta->special_pkt_period_cnt = 0;
3056
3057     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3058     if (coex_sta->c2h_bt_inquiry_page) {
3059         halbtc8723b1ant_action_bt_inquiry(btcoexist);
3060         return;
3061     } else if (bt_hs_on) {
3062         halbtc8723b1ant_action_hs(btcoexist);
3063         return;
3064     }
3065
3066     if (BTC_PACKET_DHCP == type ||
3067         BTC_PACKET_EAPOL == type) {
3068         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3069             "[BTCoex], special Packet(%d) notify\n", type);
3070         halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist);
3071     }
3072 }
3073
3074 void ex_btc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
3075                     u8 *tmp_buf, u8 length)
3076 {
3077     struct rtl_priv *rtlpriv = btcoexist->adapter;
3078     u8 bt_info = 0;
3079     u8 i, rsp_source = 0;
3080     bool wifi_connected = false;
3081     bool bt_busy = false;
3082
3083     coex_sta->c2h_bt_info_req_sent = false;
3084
3085     rsp_source = tmp_buf[0] & 0xf;
3086     if (rsp_source >= BT_INFO_SRC_8723B_1ANT_MAX)
3087         rsp_source = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
3088     coex_sta->bt_info_c2h_cnt[rsp_source]++;
3089
3090     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3091         "[BTCoex], Bt info[%d], length=%d, hex data = [",
3092          rsp_source, length);
3093     for (i = 0; i < length; i++) {
3094         coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3095         if (i == 1)
3096             bt_info = tmp_buf[i];
3097         if (i == length - 1)
3098             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3099                 "0x%02x]\n", tmp_buf[i]);
3100         else
3101             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3102                 "0x%02x, ", tmp_buf[i]);
3103     }
3104
3105     /* if 0xff, it means BT is under WHCK test */
3106     if (bt_info == 0xff)
3107         coex_sta->bt_whck_test = true;
3108     else
3109         coex_sta->bt_whck_test = false;
3110
3111     if (rsp_source != BT_INFO_SRC_8723B_1ANT_WIFI_FW) {
3112         coex_sta->bt_retry_cnt = /* [3:0] */
3113             coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3114
3115         if (coex_sta->bt_retry_cnt >= 1)
3116             coex_sta->pop_event_cnt++;
3117
3118         if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
3119             coex_sta->c2h_bt_remote_name_req = true;
3120         else
3121             coex_sta->c2h_bt_remote_name_req = false;
3122
3123         coex_sta->bt_rssi =
3124             coex_sta->bt_info_c2h[rsp_source][3] * 2 - 90;
3125
3126         coex_sta->bt_info_ext =
3127             coex_sta->bt_info_c2h[rsp_source][4];
3128
3129         if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49) {
3130             coex_sta->a2dp_bit_pool =
3131                 coex_sta->bt_info_c2h[rsp_source][6];
3132         } else {
3133             coex_sta->a2dp_bit_pool = 0;
3134         }
3135
3136         coex_sta->bt_tx_rx_mask =
3137             (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
3138         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
3139                    &coex_sta->bt_tx_rx_mask);
3140
3141         if (!coex_sta->bt_tx_rx_mask) {
3142             /* BT into is responded by BT FW and BT RF REG
3143              * 0x3C != 0x15 => Need to switch BT TRx Mask
3144              */
3145             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3146                 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
3147             btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
3148                           0x3c, 0x15);
3149
3150             /* BT TRx Mask lock 0x2c[0], 0x30[0] = 0 */
3151             btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
3152                           0x2c, 0x7c44);
3153             btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
3154                           0x30, 0x7c44);
3155         }
3156
3157         /* Here we need to resend some wifi info to BT
3158          * because bt is reset and loss of the info.
3159          */
3160         if (coex_sta->bt_info_ext & BIT1) {
3161             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3162                 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
3163             btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3164                        &wifi_connected);
3165             if (wifi_connected)
3166                 ex_btc8723b1ant_media_status_notify(btcoexist,
3167                         BTC_MEDIA_CONNECT);
3168             else
3169                 ex_btc8723b1ant_media_status_notify(btcoexist,
3170                         BTC_MEDIA_DISCONNECT);
3171         }
3172
3173         if (coex_sta->bt_info_ext & BIT3) {
3174             if (!btcoexist->manual_control &&
3175                 !btcoexist->stop_coex_dm) {
3176                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3177                     "[BTCoex], BT ext info bit3 check, set BT NOT ignore Wlan active!!\n");
3178                 halbtc8723b1ant_ignore_wlan_act(btcoexist,
3179                                 FORCE_EXEC,
3180                                 false);
3181             }
3182         } else {
3183             /* BT already NOT ignore Wlan active, do nothing here.*/
3184         }
3185         if (!btcoexist->auto_report_1ant) {
3186             if (coex_sta->bt_info_ext & BIT4) {
3187                 /* BT auto report already enabled, do nothing */
3188             } else {
3189                 halbtc8723b1ant_bt_auto_report(btcoexist,
3190                                    FORCE_EXEC,
3191                                    true);
3192             }
3193         }
3194     }
3195
3196     /* check BIT2 first ==> check if bt is under inquiry or page scan */
3197     if (bt_info & BT_INFO_8723B_1ANT_B_INQ_PAGE)
3198         coex_sta->c2h_bt_inquiry_page = true;
3199     else
3200         coex_sta->c2h_bt_inquiry_page = false;
3201
3202     coex_sta->num_of_profile = 0;
3203
3204     /* set link exist status */
3205     if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) {
3206         coex_sta->bt_link_exist = false;
3207         coex_sta->pan_exist = false;
3208         coex_sta->a2dp_exist = false;
3209         coex_sta->hid_exist = false;
3210         coex_sta->sco_exist = false;
3211
3212         coex_sta->bt_hi_pri_link_exist = false;
3213     } else {
3214         /* connection exists */
3215         coex_sta->bt_link_exist = true;
3216         if (bt_info & BT_INFO_8723B_1ANT_B_FTP) {
3217             coex_sta->pan_exist = true;
3218             coex_sta->num_of_profile++;
3219         } else {
3220             coex_sta->pan_exist = false;
3221         }
3222         if (bt_info & BT_INFO_8723B_1ANT_B_A2DP) {
3223             coex_sta->a2dp_exist = true;
3224             coex_sta->num_of_profile++;
3225         } else {
3226             coex_sta->a2dp_exist = false;
3227         }
3228         if (bt_info & BT_INFO_8723B_1ANT_B_HID) {
3229             coex_sta->hid_exist = true;
3230             coex_sta->num_of_profile++;
3231         } else {
3232             coex_sta->hid_exist = false;
3233         }
3234         if (bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) {
3235             coex_sta->sco_exist = true;
3236             coex_sta->num_of_profile++;
3237         } else {
3238             coex_sta->sco_exist = false;
3239         }
3240
3241         if ((!coex_sta->hid_exist) &&
3242             (!coex_sta->c2h_bt_inquiry_page) &&
3243             (!coex_sta->sco_exist)) {
3244             if (coex_sta->high_priority_tx +
3245                     coex_sta->high_priority_rx >=
3246                 160) {
3247                 coex_sta->hid_exist = true;
3248                 coex_sta->wrong_profile_notification++;
3249                 coex_sta->num_of_profile++;
3250                 bt_info = bt_info | 0x28;
3251             }
3252         }
3253
3254         /* Add Hi-Pri Tx/Rx counter to avoid false detection */
3255         if (((coex_sta->hid_exist) || (coex_sta->sco_exist)) &&
3256             (coex_sta->high_priority_tx + coex_sta->high_priority_rx >=
3257              160) &&
3258             (!coex_sta->c2h_bt_inquiry_page))
3259             coex_sta->bt_hi_pri_link_exist = true;
3260
3261         if ((bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) &&
3262             (coex_sta->num_of_profile == 0)) {
3263             if (coex_sta->low_priority_tx +
3264                     coex_sta->low_priority_rx >=
3265                 160) {
3266                 coex_sta->pan_exist = true;
3267                 coex_sta->num_of_profile++;
3268                 coex_sta->wrong_profile_notification++;
3269                 bt_info = bt_info | 0x88;
3270             }
3271         }
3272     }
3273
3274     halbtc8723b1ant_update_bt_link_info(btcoexist);
3275
3276     /* mask profile bit for connect-ilde identification
3277      * ( for CSR case: A2DP idle --> 0x41)
3278      */
3279     bt_info = bt_info & 0x1f;
3280
3281     if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) {
3282         coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
3283         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3284             "[BTCoex], BtInfoNotify(), BT Non-Connected idle!\n");
3285     /* connection exists but no busy */
3286     } else if (bt_info == BT_INFO_8723B_1ANT_B_CONNECTION) {
3287         coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
3288         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3289             "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3290     } else if ((bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
3291         (bt_info & BT_INFO_8723B_1ANT_B_SCO_BUSY)) {
3292         coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
3293         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3294             "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3295     } else if (bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
3296         if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
3297             coex_dm->auto_tdma_adjust = false;
3298
3299         coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
3300         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3301             "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3302     } else {
3303         coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_MAX;
3304         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3305             "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n");
3306     }
3307
3308     if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3309         (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3310         (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
3311         bt_busy = true;
3312     else
3313         bt_busy = false;
3314     btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3315
3316     halbtc8723b1ant_run_coexist_mechanism(btcoexist);
3317 }
3318
3319 void ex_btc8723b1ant_rf_status_notify(struct btc_coexist *btcoexist, u8 type)
3320 {
3321     struct rtl_priv *rtlpriv = btcoexist->adapter;
3322     u32 u32tmp;
3323     u8 u8tmpa, u8tmpb, u8tmpc;
3324
3325     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3326         "[BTCoex], RF Status notify\n");
3327
3328     if (type == BTC_RF_ON) {
3329         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3330             "[BTCoex], RF is turned ON!!\n");
3331         btcoexist->stop_coex_dm = false;
3332     } else if (type == BTC_RF_OFF) {
3333         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3334             "[BTCoex], RF is turned OFF!!\n");
3335
3336         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3337                          0x0, 0x0);
3338         halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
3339         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
3340                          FORCE_EXEC, false, true);
3341
3342         halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3343         btcoexist->stop_coex_dm = true;
3344
3345         u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
3346         u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
3347         u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
3348         u8tmpc = btcoexist->btc_read_1byte(btcoexist, 0x76e);
3349
3350         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3351             "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x, 0x76e=0x%x\n",
3352             u32tmp, u8tmpa, u8tmpb, u8tmpc);
3353     }
3354 }
3355
3356 void ex_btc8723b1ant_halt_notify(struct btc_coexist *btcoexist)
3357 {
3358     struct rtl_priv *rtlpriv = btcoexist->adapter;
3359
3360     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n");
3361
3362     btcoexist->stop_coex_dm = true;
3363
3364     halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, FORCE_EXEC,
3365                      false, true);
3366
3367     halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3368
3369     halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3370                      0x0, 0x0);
3371     halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
3372
3373     ex_btc8723b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3374
3375     btcoexist->stop_coex_dm = true;
3376 }
3377
3378 void ex_btc8723b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
3379 {
3380     struct rtl_priv *rtlpriv = btcoexist->adapter;
3381
3382     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
3383
3384     if (BTC_WIFI_PNP_SLEEP == pnp_state) {
3385         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3386             "[BTCoex], Pnp notify to SLEEP\n");
3387         halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
3388                          FORCE_EXEC, false, true);
3389         halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3390                          0x0, 0x0);
3391         halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3392         halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
3393
3394         /* Driver do not leave IPS/LPS when driver is going to sleep, so
3395          * BTCoexistence think wifi is still under IPS/LPS
3396          *
3397          * BT should clear UnderIPS/UnderLPS state to avoid mismatch
3398          * state after wakeup.
3399          */
3400         coex_sta->under_ips = false;
3401         coex_sta->under_lps = false;
3402         btcoexist->stop_coex_dm = true;
3403     } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
3404         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3405             "[BTCoex], Pnp notify to WAKE UP\n");
3406         btcoexist->stop_coex_dm = false;
3407         halbtc8723b1ant_init_hw_config(btcoexist, false, false);
3408         halbtc8723b1ant_init_coex_dm(btcoexist);
3409         halbtc8723b1ant_query_bt_info(btcoexist);
3410     }
3411 }
3412
3413 void ex_btc8723b1ant_coex_dm_reset(struct btc_coexist *btcoexist)
3414 {
3415     struct rtl_priv *rtlpriv = btcoexist->adapter;
3416
3417     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3418         "[BTCoex], *****************Coex DM Reset****************\n");
3419
3420     halbtc8723b1ant_init_hw_config(btcoexist, false, false);
3421     halbtc8723b1ant_init_coex_dm(btcoexist);
3422 }
3423
3424 void ex_btc8723b1ant_periodical(struct btc_coexist *btcoexist)
3425 {
3426     struct rtl_priv *rtlpriv = btcoexist->adapter;
3427     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3428
3429     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3430         "[BTCoex], ==========================Periodical===========================\n");
3431
3432     if (!btcoexist->auto_report_1ant) {
3433         halbtc8723b1ant_query_bt_info(btcoexist);
3434         halbtc8723b1ant_monitor_bt_enable_disable(btcoexist);
3435     } else {
3436         halbtc8723b1ant_monitor_bt_ctr(btcoexist);
3437         halbtc8723b1ant_monitor_wifi_ctr(btcoexist);
3438
3439         if ((coex_sta->high_priority_tx + coex_sta->high_priority_rx < 50) &&
3440             bt_link_info->hid_exist)
3441             bt_link_info->hid_exist = false;
3442
3443         if (btc8723b1ant_is_wifi_status_changed(btcoexist) ||
3444             coex_dm->auto_tdma_adjust) {
3445             halbtc8723b1ant_run_coexist_mechanism(btcoexist);
3446         }
3447         coex_sta->special_pkt_period_cnt++;
3448     }
3449 }