Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 2012  Realtek Corporation.*/
0003 
0004 /************************************************************
0005  * Description:
0006  *
0007  * This file is for RTL8821A Co-exist mechanism
0008  *
0009  * History
0010  * 2012/08/22 Cosa first check in.
0011  * 2012/11/14 Cosa Revise for 8821A 2Ant out sourcing.
0012  *
0013  ************************************************************/
0014 
0015 /************************************************************
0016  * include files
0017  ************************************************************/
0018 #include "halbt_precomp.h"
0019 /************************************************************
0020  * Global variables, these are static variables
0021  ************************************************************/
0022 static struct coex_dm_8821a_2ant glcoex_dm_8821a_2ant;
0023 static struct coex_dm_8821a_2ant *coex_dm = &glcoex_dm_8821a_2ant;
0024 static struct coex_sta_8821a_2ant glcoex_sta_8821a_2ant;
0025 static struct coex_sta_8821a_2ant *coex_sta = &glcoex_sta_8821a_2ant;
0026 
0027 static const char *const glbt_info_src_8821a_2ant[] = {
0028     "BT Info[wifi fw]",
0029     "BT Info[bt rsp]",
0030     "BT Info[bt auto report]",
0031 };
0032 
0033 static u32 glcoex_ver_date_8821a_2ant = 20130618;
0034 static u32 glcoex_ver_8821a_2ant = 0x5050;
0035 
0036 /************************************************************
0037  * local function proto type if needed
0038  *
0039  * local function start with btc8821a2ant_
0040  ************************************************************/
0041 static u8 btc8821a2ant_bt_rssi_state(struct btc_coexist *btcoexist,
0042                      u8 level_num, u8 rssi_thresh,
0043                      u8 rssi_thresh1)
0044 {
0045     struct rtl_priv *rtlpriv = btcoexist->adapter;
0046     long bt_rssi = 0;
0047     u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
0048 
0049     bt_rssi = coex_sta->bt_rssi;
0050 
0051     if (level_num == 2) {
0052         if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
0053             (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
0054             if (bt_rssi >=
0055                 rssi_thresh + BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT) {
0056                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
0057                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0058                     "[BTCoex], BT Rssi state switch to High\n");
0059             } else {
0060                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
0061                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0062                     "[BTCoex], BT Rssi state stay at Low\n");
0063             }
0064         } else {
0065             if (bt_rssi < rssi_thresh) {
0066                 bt_rssi_state = BTC_RSSI_STATE_LOW;
0067                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0068                     "[BTCoex], BT Rssi state switch to Low\n");
0069             } else {
0070                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
0071                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0072                     "[BTCoex], BT Rssi state stay at High\n");
0073             }
0074         }
0075     } else if (level_num == 3) {
0076         if (rssi_thresh > rssi_thresh1) {
0077             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0078                 "[BTCoex], BT Rssi thresh error!!\n");
0079             return coex_sta->pre_bt_rssi_state;
0080         }
0081 
0082         if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
0083             (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
0084             if (bt_rssi >=
0085                 (rssi_thresh +
0086                  BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
0087                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
0088                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0089                     "[BTCoex], BT Rssi state switch to Medium\n");
0090             } else {
0091                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
0092                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0093                     "[BTCoex], BT Rssi state stay at Low\n");
0094             }
0095         } else if ((coex_sta->pre_bt_rssi_state ==
0096                BTC_RSSI_STATE_MEDIUM) ||
0097                (coex_sta->pre_bt_rssi_state ==
0098                 BTC_RSSI_STATE_STAY_MEDIUM)) {
0099             if (bt_rssi >=
0100                 (rssi_thresh1 +
0101                  BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
0102                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
0103                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0104                     "[BTCoex], BT Rssi state switch to High\n");
0105             } else if (bt_rssi < rssi_thresh) {
0106                 bt_rssi_state = BTC_RSSI_STATE_LOW;
0107                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0108                     "[BTCoex], BT Rssi state switch to Low\n");
0109             } else {
0110                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
0111                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0112                     "[BTCoex], BT Rssi state stay at Medium\n");
0113             }
0114         } else {
0115             if (bt_rssi < rssi_thresh1) {
0116                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
0117                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0118                     "[BTCoex], BT Rssi state switch to Medium\n");
0119             } else {
0120                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
0121                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0122                     "[BTCoex], BT Rssi state stay at High\n");
0123             }
0124         }
0125     }
0126 
0127     coex_sta->pre_bt_rssi_state = bt_rssi_state;
0128 
0129     return bt_rssi_state;
0130 }
0131 
0132 static u8 btc8821a2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
0133                        u8 index, u8 level_num,
0134                        u8 rssi_thresh, u8 rssi_thresh1)
0135 {
0136     struct rtl_priv *rtlpriv = btcoexist->adapter;
0137     long wifi_rssi = 0;
0138     u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
0139 
0140     btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
0141 
0142     if (level_num == 2) {
0143         if ((coex_sta->pre_wifi_rssi_state[index] ==
0144              BTC_RSSI_STATE_LOW) ||
0145             (coex_sta->pre_wifi_rssi_state[index] ==
0146              BTC_RSSI_STATE_STAY_LOW)) {
0147             if (wifi_rssi >=
0148                 (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
0149                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
0150                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0151                     "[BTCoex], wifi RSSI state switch to High\n");
0152             } else {
0153                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
0154                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0155                     "[BTCoex], wifi RSSI state stay at Low\n");
0156             }
0157         } else {
0158             if (wifi_rssi < rssi_thresh) {
0159                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
0160                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0161                     "[BTCoex], wifi RSSI state switch to Low\n");
0162             } else {
0163                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
0164                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0165                     "[BTCoex], wifi RSSI state stay at High\n");
0166             }
0167         }
0168     } else if (level_num == 3) {
0169         if (rssi_thresh > rssi_thresh1) {
0170             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0171                 "[BTCoex], wifi RSSI thresh error!!\n");
0172             return coex_sta->pre_wifi_rssi_state[index];
0173         }
0174 
0175         if ((coex_sta->pre_wifi_rssi_state[index] ==
0176             BTC_RSSI_STATE_LOW) ||
0177             (coex_sta->pre_wifi_rssi_state[index] ==
0178              BTC_RSSI_STATE_STAY_LOW)) {
0179             if (wifi_rssi >=
0180                 (rssi_thresh +
0181                  BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
0182                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
0183                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0184                     "[BTCoex], wifi RSSI state switch to Medium\n");
0185             } else {
0186                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
0187                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0188                     "[BTCoex], wifi RSSI state stay at Low\n");
0189             }
0190         } else if ((coex_sta->pre_wifi_rssi_state[index] ==
0191                BTC_RSSI_STATE_MEDIUM) ||
0192                (coex_sta->pre_wifi_rssi_state[index] ==
0193                 BTC_RSSI_STATE_STAY_MEDIUM)) {
0194             if (wifi_rssi >= (rssi_thresh1 +
0195                 BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
0196                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
0197                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0198                     "[BTCoex], wifi RSSI state switch to High\n");
0199             } else if (wifi_rssi < rssi_thresh) {
0200                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
0201                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0202                     "[BTCoex], wifi RSSI state switch to Low\n");
0203             } else {
0204                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
0205                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0206                     "[BTCoex], wifi RSSI state stay at Medium\n");
0207             }
0208         } else {
0209             if (wifi_rssi < rssi_thresh1) {
0210                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
0211                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0212                     "[BTCoex], wifi RSSI state switch to Medium\n");
0213             } else {
0214                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
0215                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0216                     "[BTCoex], wifi RSSI state stay at High\n");
0217             }
0218         }
0219     }
0220     coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
0221 
0222     return wifi_rssi_state;
0223 }
0224 
0225 static
0226 void btc8821a2ant_limited_rx(struct btc_coexist *btcoexist, bool force_exec,
0227                  bool rej_ap_agg_pkt, bool bt_ctrl_agg_buf_size,
0228                  u8 agg_buf_size)
0229 {
0230     bool reject_rx_agg = rej_ap_agg_pkt;
0231     bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
0232     u8 rx_agg_size = agg_buf_size;
0233 
0234     /* Rx Aggregation related setting */
0235     btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
0236                &reject_rx_agg);
0237     /* decide BT control aggregation buf size or not */
0238     btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
0239                &bt_ctrl_rx_agg_size);
0240     /* aggregation buf size, works when BT control Rx aggregation size */
0241     btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
0242     /* real update aggregation setting */
0243     btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
0244 }
0245 
0246 static void btc8821a2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
0247 {
0248     struct rtl_priv *rtlpriv = btcoexist->adapter;
0249     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
0250     u32 reg_hp_txrx, reg_lp_txrx, u4tmp;
0251     u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
0252 
0253     reg_hp_txrx = 0x770;
0254     reg_lp_txrx = 0x774;
0255 
0256     u4tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
0257     reg_hp_tx = u4tmp & MASKLWORD;
0258     reg_hp_rx = (u4tmp & MASKHWORD) >> 16;
0259 
0260     u4tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
0261     reg_lp_tx = u4tmp & MASKLWORD;
0262     reg_lp_rx = (u4tmp & MASKHWORD) >> 16;
0263 
0264     coex_sta->high_priority_tx = reg_hp_tx;
0265     coex_sta->high_priority_rx = reg_hp_rx;
0266     coex_sta->low_priority_tx = reg_lp_tx;
0267     coex_sta->low_priority_rx = reg_lp_rx;
0268 
0269     if ((coex_sta->low_priority_rx >= 950) &&
0270         (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
0271         (!coex_sta->under_ips))
0272         bt_link_info->slave_role = true;
0273     else
0274         bt_link_info->slave_role = false;
0275 
0276     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0277         "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
0278         reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
0279     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0280         "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
0281         reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
0282 
0283     /* reset counter */
0284     btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
0285 }
0286 
0287 static void btc8821a2ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
0288 {
0289     if (coex_sta->under_ips) {
0290         coex_sta->crc_ok_cck = 0;
0291         coex_sta->crc_ok_11g = 0;
0292         coex_sta->crc_ok_11n = 0;
0293         coex_sta->crc_ok_11n_agg = 0;
0294 
0295         coex_sta->crc_err_cck = 0;
0296         coex_sta->crc_err_11g = 0;
0297         coex_sta->crc_err_11n = 0;
0298         coex_sta->crc_err_11n_agg = 0;
0299     } else {
0300         coex_sta->crc_ok_cck =
0301             btcoexist->btc_read_4byte(btcoexist, 0xf88);
0302         coex_sta->crc_ok_11g =
0303             btcoexist->btc_read_2byte(btcoexist, 0xf94);
0304         coex_sta->crc_ok_11n =
0305             btcoexist->btc_read_2byte(btcoexist, 0xf90);
0306         coex_sta->crc_ok_11n_agg =
0307             btcoexist->btc_read_2byte(btcoexist, 0xfb8);
0308 
0309         coex_sta->crc_err_cck =
0310             btcoexist->btc_read_4byte(btcoexist, 0xf84);
0311         coex_sta->crc_err_11g =
0312             btcoexist->btc_read_2byte(btcoexist, 0xf96);
0313         coex_sta->crc_err_11n =
0314             btcoexist->btc_read_2byte(btcoexist, 0xf92);
0315         coex_sta->crc_err_11n_agg =
0316             btcoexist->btc_read_2byte(btcoexist, 0xfba);
0317     }
0318 
0319     /* reset counter */
0320     btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
0321     btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
0322 }
0323 
0324 static void btc8821a2ant_query_bt_info(struct btc_coexist *btcoexist)
0325 {
0326     struct rtl_priv *rtlpriv = btcoexist->adapter;
0327     u8 h2c_parameter[1] = {0};
0328 
0329     coex_sta->c2h_bt_info_req_sent = true;
0330 
0331     h2c_parameter[0] |= BIT0; /* trigger */
0332 
0333     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0334         "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
0335         h2c_parameter[0]);
0336 
0337     btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
0338 }
0339 
0340 static bool btc8821a2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
0341 {
0342     static bool pre_wifi_busy = true;
0343     static bool pre_under_4way = true;
0344     static bool pre_bt_hs_on = true;
0345     bool wifi_busy = false, under_4way = false, bt_hs_on = false;
0346     bool wifi_connected = false;
0347     u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
0348 
0349     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
0350                &wifi_connected);
0351     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
0352     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
0353     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
0354                &under_4way);
0355 
0356     if (wifi_connected) {
0357         if (wifi_busy != pre_wifi_busy) {
0358             pre_wifi_busy = wifi_busy;
0359             return true;
0360         }
0361         if (under_4way != pre_under_4way) {
0362             pre_under_4way = under_4way;
0363             return true;
0364         }
0365         if (bt_hs_on != pre_bt_hs_on) {
0366             pre_bt_hs_on = bt_hs_on;
0367             return true;
0368         }
0369 
0370         wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 3, 2,
0371                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
0372 
0373         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
0374             (wifi_rssi_state == BTC_RSSI_STATE_LOW))
0375             return true;
0376     }
0377 
0378     return false;
0379 }
0380 
0381 static void btc8821a2ant_update_bt_link_info(struct btc_coexist *btcoexist)
0382 {
0383     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
0384     bool bt_hs_on = false;
0385 
0386     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
0387 
0388     bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
0389     bt_link_info->sco_exist = coex_sta->sco_exist;
0390     bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
0391     bt_link_info->pan_exist = coex_sta->pan_exist;
0392     bt_link_info->hid_exist = coex_sta->hid_exist;
0393 
0394     /* work around for HS mode. */
0395     if (bt_hs_on) {
0396         bt_link_info->pan_exist = true;
0397         bt_link_info->bt_link_exist = true;
0398     }
0399 
0400     /* check if Sco only */
0401     if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
0402         !bt_link_info->pan_exist && !bt_link_info->hid_exist)
0403         bt_link_info->sco_only = true;
0404     else
0405         bt_link_info->sco_only = false;
0406 
0407     /* check if A2dp only */
0408     if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
0409         !bt_link_info->pan_exist && !bt_link_info->hid_exist)
0410         bt_link_info->a2dp_only = true;
0411     else
0412         bt_link_info->a2dp_only = false;
0413 
0414     /* check if Pan only */
0415     if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
0416         bt_link_info->pan_exist && !bt_link_info->hid_exist)
0417         bt_link_info->pan_only = true;
0418     else
0419         bt_link_info->pan_only = false;
0420 
0421     /* check if Hid only */
0422     if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
0423         !bt_link_info->pan_exist && bt_link_info->hid_exist)
0424         bt_link_info->hid_only = true;
0425     else
0426         bt_link_info->hid_only = false;
0427 }
0428 
0429 static u8 btc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
0430 {
0431     struct rtl_priv *rtlpriv = btcoexist->adapter;
0432     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
0433     bool bt_hs_on = false;
0434     u8 algorithm = BT_8821A_2ANT_COEX_ALGO_UNDEFINED;
0435     u8 num_of_diff_profile = 0;
0436 
0437     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
0438 
0439     if (!bt_link_info->bt_link_exist) {
0440         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0441             "[BTCoex], No BT link exists!!!\n");
0442         return algorithm;
0443     }
0444 
0445     if (bt_link_info->sco_exist)
0446         num_of_diff_profile++;
0447     if (bt_link_info->hid_exist)
0448         num_of_diff_profile++;
0449     if (bt_link_info->pan_exist)
0450         num_of_diff_profile++;
0451     if (bt_link_info->a2dp_exist)
0452         num_of_diff_profile++;
0453 
0454     if (num_of_diff_profile == 1) {
0455         if (bt_link_info->sco_exist) {
0456             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0457                 "[BTCoex], SCO only\n");
0458             algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0459         } else {
0460             if (bt_link_info->hid_exist) {
0461                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0462                     "[BTCoex], HID only\n");
0463                 algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
0464             } else if (bt_link_info->a2dp_exist) {
0465                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0466                     "[BTCoex], A2DP only\n");
0467                 algorithm = BT_8821A_2ANT_COEX_ALGO_A2DP;
0468             } else if (bt_link_info->pan_exist) {
0469                 if (bt_hs_on) {
0470                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0471                         DBG_LOUD,
0472                         "[BTCoex], PAN(HS) only\n");
0473                     algorithm = BT_8821A_2ANT_COEX_ALGO_PANHS;
0474                 } else {
0475                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0476                         DBG_LOUD,
0477                         "[BTCoex], PAN(EDR) only\n");
0478                     algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR;
0479                 }
0480             }
0481         }
0482     } else if (num_of_diff_profile == 2) {
0483         if (bt_link_info->sco_exist) {
0484             if (bt_link_info->hid_exist) {
0485                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0486                     "[BTCoex], SCO + HID\n");
0487                 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0488             } else if (bt_link_info->a2dp_exist) {
0489                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0490                     "[BTCoex], SCO + A2DP ==> SCO\n");
0491                 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0492             } else if (bt_link_info->pan_exist) {
0493                 if (bt_hs_on) {
0494                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0495                         DBG_LOUD,
0496                         "[BTCoex], SCO + PAN(HS)\n");
0497                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0498                 } else {
0499                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0500                         DBG_LOUD,
0501                         "[BTCoex], SCO + PAN(EDR)\n");
0502                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0503                 }
0504             }
0505         } else {
0506             if (bt_link_info->hid_exist &&
0507                 bt_link_info->a2dp_exist) {
0508                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0509                     "[BTCoex], HID + A2DP\n");
0510                 algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
0511             } else if (bt_link_info->hid_exist &&
0512                 bt_link_info->pan_exist) {
0513                 if (bt_hs_on) {
0514                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0515                         DBG_LOUD,
0516                         "[BTCoex], HID + PAN(HS)\n");
0517                     algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
0518                 } else {
0519                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0520                         DBG_LOUD,
0521                         "[BTCoex], HID + PAN(EDR)\n");
0522                     algorithm =
0523                         BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
0524                 }
0525             } else if (bt_link_info->pan_exist &&
0526                 bt_link_info->a2dp_exist) {
0527                 if (bt_hs_on) {
0528                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0529                         DBG_LOUD,
0530                         "[BTCoex], A2DP + PAN(HS)\n");
0531                     algorithm =
0532                         BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS;
0533                 } else {
0534                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0535                         DBG_LOUD,
0536                         "[BTCoex], A2DP + PAN(EDR)\n");
0537                     algorithm =
0538                         BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP;
0539                 }
0540             }
0541         }
0542     } else if (num_of_diff_profile == 3) {
0543         if (bt_link_info->sco_exist) {
0544             if (bt_link_info->hid_exist &&
0545                 bt_link_info->a2dp_exist) {
0546                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0547                     "[BTCoex], SCO + HID + A2DP ==> HID\n");
0548                 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0549             } else if (bt_link_info->hid_exist &&
0550                 bt_link_info->pan_exist) {
0551                 if (bt_hs_on) {
0552                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0553                         DBG_LOUD,
0554                         "[BTCoex], SCO + HID + PAN(HS)\n");
0555                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0556                 } else {
0557                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0558                         DBG_LOUD,
0559                         "[BTCoex], SCO + HID + PAN(EDR)\n");
0560                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0561                 }
0562             } else if (bt_link_info->pan_exist &&
0563                    bt_link_info->a2dp_exist) {
0564                 if (bt_hs_on) {
0565                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0566                         DBG_LOUD,
0567                         "[BTCoex], SCO + A2DP + PAN(HS)\n");
0568                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0569                 } else {
0570                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0571                         DBG_LOUD,
0572                         "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
0573                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0574                 }
0575             }
0576         } else {
0577             if (bt_link_info->hid_exist &&
0578                 bt_link_info->pan_exist &&
0579                 bt_link_info->a2dp_exist) {
0580                 if (bt_hs_on) {
0581                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0582                         DBG_LOUD,
0583                         "[BTCoex], HID + A2DP + PAN(HS)\n");
0584                     algorithm =
0585                         BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
0586                 } else {
0587                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0588                         DBG_LOUD,
0589                         "[BTCoex], HID + A2DP + PAN(EDR)\n");
0590                     algorithm =
0591                     BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
0592                 }
0593             }
0594         }
0595     } else if (num_of_diff_profile >= 3) {
0596         if (bt_link_info->sco_exist) {
0597             if (bt_link_info->hid_exist &&
0598                 bt_link_info->pan_exist &&
0599                 bt_link_info->a2dp_exist) {
0600                 if (bt_hs_on) {
0601                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0602                         DBG_LOUD,
0603                         "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
0604 
0605                 } else {
0606                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
0607                         DBG_LOUD,
0608                         "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
0609                     algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
0610                 }
0611             }
0612         }
0613     }
0614     return algorithm;
0615 }
0616 
0617 static void btc8821a2ant_set_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
0618                           u8 dac_swing_lvl)
0619 {
0620     struct rtl_priv *rtlpriv = btcoexist->adapter;
0621     u8 h2c_parameter[1] = {0};
0622 
0623     /* There are several type of dacswing
0624      * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
0625      */
0626     h2c_parameter[0] = dac_swing_lvl;
0627 
0628     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0629         "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swing_lvl);
0630     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0631         "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
0632 
0633     btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
0634 }
0635 
0636 static void btc8821a2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
0637                        u8 dec_bt_pwr_lvl)
0638 {
0639     struct rtl_priv *rtlpriv = btcoexist->adapter;
0640     u8 h2c_parameter[1] = {0};
0641 
0642     h2c_parameter[0] = dec_bt_pwr_lvl;
0643 
0644     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0645         "[BTCoex], decrease Bt Power Level : %u, FW write 0x62 = 0x%x\n",
0646         dec_bt_pwr_lvl, h2c_parameter[0]);
0647 
0648     btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
0649 }
0650 
0651 static void btc8821a2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
0652                     bool force_exec, u8 dec_bt_pwr_lvl)
0653 {
0654     struct rtl_priv *rtlpriv = btcoexist->adapter;
0655 
0656     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0657         "[BTCoex], %s Dec BT power level = %u\n",
0658         (force_exec ? "force to" : ""), dec_bt_pwr_lvl);
0659     coex_dm->cur_dec_bt_pwr_lvl = dec_bt_pwr_lvl;
0660 
0661     if (!force_exec) {
0662         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0663             "[BTCoex], pre_dec_bt_pwr_lvl = %d, cur_dec_bt_pwr_lvl = %d\n",
0664             coex_dm->pre_dec_bt_pwr_lvl,
0665                 coex_dm->cur_dec_bt_pwr_lvl);
0666 
0667         if (coex_dm->pre_dec_bt_pwr_lvl == coex_dm->cur_dec_bt_pwr_lvl)
0668             return;
0669     }
0670     btc8821a2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr_lvl);
0671 
0672     coex_dm->pre_dec_bt_pwr_lvl = coex_dm->cur_dec_bt_pwr_lvl;
0673 }
0674 
0675 static void btc8821a2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
0676                       bool force_exec, u8 fw_dac_swing_lvl)
0677 {
0678     struct rtl_priv *rtlpriv = btcoexist->adapter;
0679 
0680     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0681         "[BTCoex], %s set FW Dac Swing level = %d\n",
0682         (force_exec ? "force to" : ""), fw_dac_swing_lvl);
0683     coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
0684 
0685     if (!force_exec) {
0686         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0687             "[BTCoex], pre_fw_dac_swing_lvl = %d, cur_fw_dac_swing_lvl = %d\n",
0688             coex_dm->pre_fw_dac_swing_lvl,
0689             coex_dm->cur_fw_dac_swing_lvl);
0690 
0691         if (coex_dm->pre_fw_dac_swing_lvl ==
0692             coex_dm->cur_fw_dac_swing_lvl)
0693             return;
0694     }
0695 
0696     btc8821a2ant_set_fw_dac_swing_lvl(btcoexist,
0697                       coex_dm->cur_fw_dac_swing_lvl);
0698 
0699     coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
0700 }
0701 
0702 static void btc8821a2ant_set_sw_penalty_tx_rate_adaptive(
0703         struct btc_coexist *btcoexist, bool low_penalty_ra)
0704 {
0705     struct rtl_priv *rtlpriv = btcoexist->adapter;
0706     u8 h2c_parameter[6] = {0};
0707 
0708     h2c_parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
0709 
0710     if (low_penalty_ra) {
0711         h2c_parameter[1] |= BIT0;
0712         /* normal rate except MCS7/6/5, OFDM54/48/36 */
0713         h2c_parameter[2] = 0x00;
0714         /* MCS7 or OFDM54 */
0715         h2c_parameter[3] = 0xf5;
0716         /* MCS6 or OFDM48 */
0717         h2c_parameter[4] = 0xa0;
0718         /* MCS5 or OFDM36 */
0719         h2c_parameter[5] = 0xa0;
0720     }
0721 
0722     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0723         "[BTCoex], set WiFi Low-Penalty Retry: %s",
0724         (low_penalty_ra ? "ON!!" : "OFF!!"));
0725 
0726     btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
0727 }
0728 
0729 static void btc8821a2ant_low_penalty_ra(struct btc_coexist *btcoexist,
0730                     bool force_exec, bool low_penalty_ra)
0731 {
0732     struct rtl_priv *rtlpriv = btcoexist->adapter;
0733 
0734     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0735         "[BTCoex], %s turn LowPenaltyRA = %s\n",
0736         (force_exec ? "force to" : ""),
0737         ((low_penalty_ra) ? "ON" : "OFF"));
0738     coex_dm->cur_low_penalty_ra = low_penalty_ra;
0739 
0740     if (!force_exec) {
0741         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0742             "[BTCoex], pre_low_penalty_ra = %d, cur_low_penalty_ra = %d\n",
0743             coex_dm->pre_low_penalty_ra,
0744             coex_dm->cur_low_penalty_ra);
0745 
0746         if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
0747             return;
0748     }
0749     btc8821a2ant_set_sw_penalty_tx_rate_adaptive(btcoexist,
0750                      coex_dm->cur_low_penalty_ra);
0751 
0752     coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
0753 }
0754 
0755 static void btc8821a2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
0756                        u32 level)
0757 {
0758     struct rtl_priv *rtlpriv = btcoexist->adapter;
0759     u8 val = (u8)level;
0760 
0761     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0762         "[BTCoex], Write SwDacSwing = 0x%x\n", level);
0763     btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc5b, 0x3e, val);
0764 }
0765 
0766 static void btc8821a2ant_set_sw_full_dac_swing(struct btc_coexist *btcoexist,
0767                            bool sw_dac_swing_on,
0768                            u32 sw_dac_swing_lvl)
0769 {
0770     if (sw_dac_swing_on)
0771         btc8821a2ant_set_dac_swing_reg(btcoexist, sw_dac_swing_lvl);
0772     else
0773         btc8821a2ant_set_dac_swing_reg(btcoexist, 0x18);
0774 }
0775 
0776 static void btc8821a2ant_dac_swing(struct btc_coexist *btcoexist,
0777                    bool force_exec, bool dac_swing_on,
0778                    u32 dac_swing_lvl)
0779 {
0780     struct rtl_priv *rtlpriv = btcoexist->adapter;
0781 
0782     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0783         "[BTCoex], %s turn DacSwing = %s, dac_swing_lvl = 0x%x\n",
0784         (force_exec ? "force to" : ""),
0785         ((dac_swing_on) ? "ON" : "OFF"),
0786         dac_swing_lvl);
0787     coex_dm->cur_dac_swing_on = dac_swing_on;
0788     coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
0789 
0790     if (!force_exec) {
0791         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0792             "[BTCoex], pre_dac_swing_on = %d, pre_dac_swing_lvl = 0x%x, cur_dac_swing_on = %d, cur_dac_swing_lvl = 0x%x\n",
0793             coex_dm->pre_dac_swing_on,
0794             coex_dm->pre_dac_swing_lvl,
0795             coex_dm->cur_dac_swing_on,
0796             coex_dm->cur_dac_swing_lvl);
0797 
0798         if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
0799             (coex_dm->pre_dac_swing_lvl ==
0800              coex_dm->cur_dac_swing_lvl))
0801             return;
0802     }
0803     mdelay(30);
0804     btc8821a2ant_set_sw_full_dac_swing(btcoexist, dac_swing_on,
0805                        dac_swing_lvl);
0806 
0807     coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
0808     coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
0809 }
0810 
0811 static void btc8821a2ant_set_coex_table(struct btc_coexist *btcoexist,
0812                     u32 val0x6c0, u32 val0x6c4,
0813                     u32 val0x6c8, u8 val0x6cc)
0814 {
0815     struct rtl_priv *rtlpriv = btcoexist->adapter;
0816 
0817     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0818         "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
0819     btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
0820 
0821     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0822         "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
0823     btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
0824 
0825     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0826         "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
0827     btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
0828 
0829     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0830         "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
0831     btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
0832 }
0833 
0834 static void btc8821a2ant_coex_table(struct btc_coexist *btcoexist,
0835                     bool force_exec, u32 val0x6c0,
0836                     u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
0837 {
0838     struct rtl_priv *rtlpriv = btcoexist->adapter;
0839 
0840     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0841         "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
0842         (force_exec ? "force to" : ""),
0843         val0x6c0, val0x6c4, val0x6c8, val0x6cc);
0844     coex_dm->cur_val0x6c0 = val0x6c0;
0845     coex_dm->cur_val0x6c4 = val0x6c4;
0846     coex_dm->cur_val0x6c8 = val0x6c8;
0847     coex_dm->cur_val0x6cc = val0x6cc;
0848 
0849     if (!force_exec) {
0850         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0851             "[BTCoex], pre_val0x6c0 = 0x%x, pre_val0x6c4 = 0x%x, pre_val0x6c8 = 0x%x, pre_val0x6cc = 0x%x !!\n",
0852             coex_dm->pre_val0x6c0,
0853             coex_dm->pre_val0x6c4,
0854             coex_dm->pre_val0x6c8,
0855             coex_dm->pre_val0x6cc);
0856         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0857             "[BTCoex], cur_val0x6c0 = 0x%x, cur_val0x6c4 = 0x%x, cur_val0x6c8 = 0x%x, cur_val0x6cc = 0x%x !!\n",
0858             coex_dm->cur_val0x6c0,
0859             coex_dm->cur_val0x6c4,
0860             coex_dm->cur_val0x6c8,
0861             coex_dm->cur_val0x6cc);
0862 
0863         if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
0864             (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
0865             (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
0866             (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
0867             return;
0868     }
0869     btc8821a2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
0870                     val0x6cc);
0871 
0872     coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
0873     coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
0874     coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
0875     coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
0876 }
0877 
0878 static void btc8821a2ant_coex_table_with_type(struct btc_coexist *btcoexist,
0879                           bool force_exec, u8 type)
0880 {
0881     coex_sta->coex_table_type = type;
0882 
0883     switch (type) {
0884     case 0:
0885         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55555555,
0886                     0x55555555, 0xffffff, 0x3);
0887         break;
0888     case 1:
0889         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55555555,
0890                     0x5afa5afa, 0xffffff, 0x3);
0891         break;
0892     case 2:
0893         btc8821a2ant_coex_table(btcoexist, force_exec, 0x5ada5ada,
0894                     0x5ada5ada, 0xffffff, 0x3);
0895         break;
0896     case 3:
0897         btc8821a2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
0898                     0xaaaaaaaa, 0xffffff, 0x3);
0899         break;
0900     case 4:
0901         btc8821a2ant_coex_table(btcoexist, force_exec, 0xffffffff,
0902                     0xffffffff, 0xffffff, 0x3);
0903         break;
0904     case 5:
0905         btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
0906                     0x5fff5fff, 0xffffff, 0x3);
0907         break;
0908     case 6:
0909         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
0910                     0x5a5a5a5a, 0xffffff, 0x3);
0911         break;
0912     case 7:
0913         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0914                     0x5ada5ada, 0xffffff, 0x3);
0915         break;
0916     case 8:
0917         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0918                     0x5ada5ada, 0xffffff, 0x3);
0919         break;
0920     case 9:
0921         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0922                     0x5ada5ada, 0xffffff, 0x3);
0923         break;
0924     case 10:
0925         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0926                     0x5ada5ada, 0xffffff, 0x3);
0927         break;
0928     case 11:
0929         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0930                     0x5ada5ada, 0xffffff, 0x3);
0931         break;
0932     case 12:
0933         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0934                     0x5ada5ada, 0xffffff, 0x3);
0935         break;
0936     case 13:
0937         btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
0938                     0xaaaaaaaa, 0xffffff, 0x3);
0939         break;
0940     case 14:
0941         btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
0942                     0x5ada5ada, 0xffffff, 0x3);
0943         break;
0944     case 15:
0945         btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
0946                     0xaaaaaaaa, 0xffffff, 0x3);
0947         break;
0948     case 16:
0949         btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fdf5fdf,
0950                     0x5fdb5fdb, 0xffffff, 0x3);
0951         break;
0952     case 17:
0953         btc8821a2ant_coex_table(btcoexist, force_exec, 0xfafafafa,
0954                     0xfafafafa, 0xffffff, 0x3);
0955         break;
0956     default:
0957         break;
0958     }
0959 }
0960 
0961 static void btc8821a2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoex,
0962                         bool enable)
0963 {
0964     struct rtl_priv *rtlpriv = btcoex->adapter;
0965     u8 h2c_parameter[1] = {0};
0966 
0967     if (enable)
0968         h2c_parameter[0] |= BIT0; /* function enable */
0969 
0970     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
0971         "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
0972         h2c_parameter[0]);
0973 
0974     btcoex->btc_fill_h2c(btcoex, 0x63, 1, h2c_parameter);
0975 }
0976 
0977 static void btc8821a2ant_set_lps_rpwm(struct btc_coexist *btcoexist, u8 lps_val,
0978                       u8 rpwm_val)
0979 {
0980     u8 lps = lps_val;
0981     u8 rpwm = rpwm_val;
0982 
0983     btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
0984     btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
0985 }
0986 
0987 static void btc8821a2ant_lps_rpwm(struct btc_coexist *btcoexist,
0988                   bool force_exec, u8 lps_val, u8 rpwm_val)
0989 {
0990     coex_dm->cur_lps = lps_val;
0991     coex_dm->cur_rpwm = rpwm_val;
0992 
0993     if (!force_exec) {
0994         if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
0995             (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
0996             return;
0997     }
0998     btc8821a2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
0999 
1000     coex_dm->pre_lps = coex_dm->cur_lps;
1001     coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1002 }
1003 
1004 static void btc8821a2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1005                      bool force_exec, bool enable)
1006 {
1007     struct rtl_priv *rtlpriv = btcoexist->adapter;
1008 
1009     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1010         "[BTCoex], %s turn Ignore WlanAct %s\n",
1011         (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1012     coex_dm->cur_ignore_wlan_act = enable;
1013 
1014     if (!force_exec) {
1015         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1016             "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
1017             coex_dm->pre_ignore_wlan_act,
1018              coex_dm->cur_ignore_wlan_act);
1019 
1020         if (coex_dm->pre_ignore_wlan_act ==
1021             coex_dm->cur_ignore_wlan_act)
1022             return;
1023     }
1024     btc8821a2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1025 
1026     coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1027 }
1028 
1029 static void btc8821a2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist,
1030                     u8 byte1, u8 byte2, u8 byte3,
1031                     u8 byte4, u8 byte5)
1032 {
1033     struct rtl_priv *rtlpriv = btcoexist->adapter;
1034     u8 h2c_parameter[5];
1035 
1036     h2c_parameter[0] = byte1;
1037     h2c_parameter[1] = byte2;
1038     h2c_parameter[2] = byte3;
1039     h2c_parameter[3] = byte4;
1040     h2c_parameter[4] = byte5;
1041 
1042     coex_dm->ps_tdma_para[0] = byte1;
1043     coex_dm->ps_tdma_para[1] = byte2;
1044     coex_dm->ps_tdma_para[2] = byte3;
1045     coex_dm->ps_tdma_para[3] = byte4;
1046     coex_dm->ps_tdma_para[4] = byte5;
1047 
1048     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1049         "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
1050         h2c_parameter[0],
1051         h2c_parameter[1] << 24 |
1052         h2c_parameter[2] << 16 |
1053         h2c_parameter[3] << 8 |
1054         h2c_parameter[4]);
1055 
1056     btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1057 }
1058 
1059 static void btc8821a2ant_sw_mechanism1(struct btc_coexist *btcoexist,
1060                        bool shrink_rx_lpf, bool low_penalty_ra,
1061                        bool limited_dig, bool bt_lna_constrain)
1062 {
1063     btc8821a2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1064 }
1065 
1066 static void btc8821a2ant_sw_mechanism2(struct btc_coexist *btcoexist,
1067                        bool agc_table_shift, bool adc_back_off,
1068                        bool sw_dac_swing, u32 dac_swing_lvl)
1069 {
1070     btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1071                    dac_swing_lvl);
1072 }
1073 
1074 static void btc8821a2ant_set_ant_path(struct btc_coexist *btcoexist,
1075                       u8 ant_pos_type, bool init_hw_cfg,
1076                       bool wifi_off)
1077 {
1078     struct btc_board_info *board_info = &btcoexist->board_info;
1079     u32 u4tmp = 0;
1080     u8 h2c_parameter[2] = {0};
1081 
1082     if (init_hw_cfg) {
1083         /*  0x4c[23] = 0, 0x4c[24] = 1  Antenna control by WL/BT */
1084         u4tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1085         u4tmp &= ~BIT23;
1086         u4tmp |= BIT24;
1087         btcoexist->btc_write_4byte(btcoexist, 0x4c, u4tmp);
1088 
1089         btcoexist->btc_write_4byte(btcoexist, 0x974, 0x3ff);
1090 
1091         if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1092             /* tell firmware "antenna inverse"  ==> WRONG firmware
1093              * antenna control code ==>need fw to fix
1094              */
1095             h2c_parameter[0] = 1;
1096             h2c_parameter[1] = 1;
1097             btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1098                         h2c_parameter);
1099         } else {
1100             /* tell firmware "no antenna inverse" ==> WRONG firmware
1101              * antenna control code ==>need fw to fix
1102              */
1103             h2c_parameter[0] = 0;
1104             h2c_parameter[1] = 1;
1105             btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1106                         h2c_parameter);
1107         }
1108     }
1109 
1110     /* ext switch setting */
1111     switch (ant_pos_type) {
1112     case BTC_ANT_WIFI_AT_MAIN:
1113         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x1);
1114         break;
1115     case BTC_ANT_WIFI_AT_AUX:
1116         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x2);
1117         break;
1118     }
1119 }
1120 
1121 static void btc8821a2ant_ps_tdma(struct btc_coexist *btcoexist,
1122                  bool force_exec, bool turn_on, u8 type)
1123 {
1124     struct rtl_priv *rtlpriv = btcoexist->adapter;
1125 
1126     u8 wifi_rssi_state, bt_rssi_state;
1127 
1128     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1129                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
1130     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist, 2,
1131                 BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1132 
1133     if (!(BTC_RSSI_HIGH(wifi_rssi_state) &&
1134           BTC_RSSI_HIGH(bt_rssi_state)) &&
1135         turn_on) {
1136         /* for WiFi RSSI low or BT RSSI low */
1137         type = type + 100;
1138     }
1139 
1140     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1141         "[BTCoex], %s turn %s PS TDMA, type = %d\n",
1142         (force_exec ? "force to" : ""), (turn_on ? "ON" : "OFF"),
1143         type);
1144     coex_dm->cur_ps_tdma_on = turn_on;
1145     coex_dm->cur_ps_tdma = type;
1146 
1147     if (!force_exec) {
1148         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1149             "[BTCoex], pre_ps_tdma_on = %d, cur_ps_tdma_on = %d!!\n",
1150             coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1151         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1152             "[BTCoex], pre_ps_tdma = %d, cur_ps_tdma = %d!!\n",
1153             coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1154 
1155         if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1156             (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1157             return;
1158     }
1159     if (turn_on) {
1160         switch (type) {
1161         case 1:
1162         default:
1163             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1164                             0x03, 0xf1, 0x90);
1165             break;
1166         case 2:
1167             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1168                             0x03, 0xf1, 0x90);
1169             break;
1170         case 3:
1171             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1172                             0x3, 0xf1, 0x90);
1173             break;
1174         case 4:
1175             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1176                             0x03, 0xf1, 0x90);
1177             break;
1178         case 5:
1179             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1180                             0x3, 0x70, 0x90);
1181             break;
1182         case 6:
1183             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1184                             0x3, 0x70, 0x90);
1185             break;
1186         case 7:
1187             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1188                             0x3, 0x70, 0x90);
1189             break;
1190         case 8:
1191             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1192                             0x3, 0x70, 0x90);
1193             break;
1194         case 9:
1195             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1196                             0x03, 0xf1, 0x90);
1197             break;
1198         case 10:
1199             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1200                             0x03, 0xf1, 0x90);
1201             break;
1202         case 11:
1203             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1204                             0x3, 0xf1, 0x90);
1205             break;
1206         case 12:
1207             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1208                             0x3, 0xf1, 0x90);
1209             break;
1210         case 13:
1211             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1212                             0x3, 0x70, 0x90);
1213             break;
1214         case 14:
1215             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1216                             0x3, 0x70, 0x90);
1217             break;
1218         case 15:
1219             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1220                             0x3, 0x70, 0x90);
1221             break;
1222         case 16:
1223             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1224                             0x3, 0x70, 0x90);
1225             break;
1226         case 17:
1227             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1228                             0x2f, 0x60, 0x90);
1229             break;
1230         case 18:
1231             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 0x5,
1232                             0xe1, 0x90);
1233             break;
1234         case 19:
1235             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1236                             0x25, 0xe1, 0x90);
1237             break;
1238         case 20:
1239             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1240                             0x25, 0x60, 0x90);
1241             break;
1242         case 21:
1243             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1244                             0x03, 0x70, 0x90);
1245             break;
1246         case 23:
1247             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1e,
1248                             0x03, 0xf0, 0x14);
1249             break;
1250         case 24:
1251         case 124:
1252             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x3c,
1253                             0x03, 0x70, 0x50);
1254             break;
1255         case 25:
1256             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x14,
1257                             0x03, 0xf1, 0x90);
1258             break;
1259         case 26:
1260             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x30,
1261                             0x03, 0xf1, 0x90);
1262             break;
1263         case 71:
1264             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1265                             0x03, 0xf1, 0x90);
1266             break;
1267         case 101:
1268         case 105:
1269         case 171:
1270             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x3a,
1271                             0x03, 0x70, 0x50);
1272             break;
1273         case 102:
1274         case 106:
1275         case 110:
1276         case 114:
1277             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x2d,
1278                             0x03, 0x70, 0x50);
1279             break;
1280         case 103:
1281         case 107:
1282         case 111:
1283         case 115:
1284             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1285                             0x03, 0x70, 0x50);
1286             break;
1287         case 104:
1288         case 108:
1289         case 112:
1290         case 116:
1291             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x10,
1292                             0x03, 0x70, 0x50);
1293             break;
1294         case 109:
1295             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1296                             0x03, 0xf1, 0x90);
1297             break;
1298         case 113:
1299             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1300                             0x03, 0x70, 0x90);
1301             break;
1302         case 121:
1303             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1304                             0x03, 0x70, 0x90);
1305             break;
1306         case 22:
1307         case 122:
1308             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1309                             0x03, 0x71, 0x11);
1310             break;
1311         case 123:
1312             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1313                             0x03, 0x70, 0x54);
1314             break;
1315         case 125:
1316             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x14,
1317                             0x03, 0x70, 0x50);
1318             break;
1319         case 126:
1320             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x30,
1321                             0x03, 0x70, 0x50);
1322             break;
1323         }
1324     } else {
1325         /* disable PS tdma */
1326         switch (type) {
1327         case 0:
1328             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1329                             0x40, 0x0);
1330             break;
1331         case 1:
1332             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1333                             0x48, 0x0);
1334             break;
1335         default:
1336             btc8821a2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1337                             0x40, 0x0);
1338             break;
1339         }
1340     }
1341 
1342     /* update pre state */
1343     coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1344     coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1345 }
1346 
1347 static void
1348 btc8821a2ant_ps_tdma_check_for_power_save_state(struct btc_coexist *btcoexist,
1349                         bool new_ps_state)
1350 {
1351     u8 lps_mode = 0x0;
1352 
1353     btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1354 
1355     if (lps_mode) {
1356         /* already under LPS state */
1357         if (new_ps_state) {
1358             /* keep state under LPS, do nothing */
1359         } else {
1360             /* will leave LPS state, turn off psTdma first */
1361             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1362         }
1363     } else {
1364         /* NO PS state */
1365         if (new_ps_state) {
1366             /* will enter LPS state, turn off psTdma first */
1367             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1368         } else {
1369             /* keep state under NO PS state, do nothing */
1370         }
1371     }
1372 }
1373 
1374 static void btc8821a2ant_power_save_state(struct btc_coexist *btcoexist,
1375                       u8 ps_type, u8 lps_val, u8 rpwm_val)
1376 {
1377     bool low_pwr_disable = false;
1378 
1379     switch (ps_type) {
1380     case BTC_PS_WIFI_NATIVE:
1381         /* recover to original 32k low power setting */
1382         low_pwr_disable = false;
1383         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1384                    &low_pwr_disable);
1385         btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1386         coex_sta->force_lps_on = false;
1387         break;
1388     case BTC_PS_LPS_ON:
1389         btc8821a2ant_ps_tdma_check_for_power_save_state(btcoexist,
1390                                 true);
1391         btc8821a2ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1392                       rpwm_val);
1393         /* when coex force to enter LPS, do not enter 32k low power */
1394         low_pwr_disable = true;
1395         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1396                    &low_pwr_disable);
1397         /* power save must executed before psTdma */
1398         btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1399         coex_sta->force_lps_on = true;
1400         break;
1401     case BTC_PS_LPS_OFF:
1402         btc8821a2ant_ps_tdma_check_for_power_save_state(btcoexist,
1403                                 false);
1404         btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1405         coex_sta->force_lps_on = false;
1406         break;
1407     default:
1408         break;
1409     }
1410 }
1411 
1412 static void btc8821a2ant_coex_all_off(struct btc_coexist *btcoexist)
1413 {
1414     /* fw all off */
1415     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1416     btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1417     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1418     btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1419 
1420     /* sw all off */
1421     btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1422     btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1423 
1424     /* hw all off */
1425     btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1426 }
1427 
1428 static void btc8821a2ant_coex_under_5g(struct btc_coexist *btcoexist)
1429 {
1430     btc8821a2ant_coex_all_off(btcoexist);
1431     btc8821a2ant_ignore_wlan_act(btcoexist, NORMAL_EXEC, true);
1432 }
1433 
1434 static void btc8821a2ant_init_coex_dm(struct btc_coexist *btcoexist)
1435 {
1436     /* force to reset coex mechanism */
1437     btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1438 
1439     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1440     btc8821a2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1441     btc8821a2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1442     btc8821a2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 0);
1443 
1444     btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1445     btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1446 }
1447 
1448 static void btc8821a2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1449 {
1450     struct rtl_priv *rtlpriv = btcoexist->adapter;
1451     bool wifi_connected = false;
1452     bool low_pwr_disable = true;
1453     bool scan = false, link = false, roam = false;
1454 
1455     btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1456     btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1457                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
1458     btc8821a2ant_bt_rssi_state(btcoexist,
1459                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1460 
1461     btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1462                &low_pwr_disable);
1463     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1464                &wifi_connected);
1465 
1466     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1467     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1468     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1469 
1470     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1471 
1472     if (scan || link || roam) {
1473         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1474             "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1475         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1476         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1477     } else if (wifi_connected) {
1478         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1479             "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1480         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1481         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1482     } else {
1483         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1484             "[BTCoex], Wifi no-link + BT Inq/Page!!\n");
1485         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1486         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1487     }
1488 
1489     btc8821a2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1490     btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1491 
1492     btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1493     btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1494 }
1495 
1496 static void btc8821a2ant_action_wifi_link_process(struct btc_coexist *btcoexist)
1497 {
1498     struct rtl_priv *rtlpriv = btcoexist->adapter;
1499     u8 u8tmpa, u8tmpb;
1500 
1501     btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1502     btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1503 
1504     btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1505     btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1506 
1507     u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1508     u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1509 
1510     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1511         "[BTCoex], 0x765=0x%x, 0x76e=0x%x\n", u8tmpa, u8tmpb);
1512 }
1513 
1514 static bool btc8821a2ant_action_wifi_idle_process(struct btc_coexist *btcoexist)
1515 {
1516     struct rtl_priv *rtlpriv = btcoexist->adapter;
1517     u8 wifi_rssi_state1;
1518     u8 ap_num = 0;
1519 
1520     btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1521     wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1522             BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES - 20, 0);
1523     btc8821a2ant_bt_rssi_state(btcoexist,
1524                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1525 
1526     btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1527 
1528     /* define the office environment */
1529     if (BTC_RSSI_HIGH(wifi_rssi_state1) && (coex_sta->hid_exist) &&
1530         (coex_sta->a2dp_exist)) {
1531         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1532             "[BTCoex], Wifi  idle process for BT HID+A2DP exist!!\n");
1533 
1534         btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1535         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1536 
1537         /* sw all off */
1538         btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1539                        false);
1540         btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1541                        0x18);
1542 
1543         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1544         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1545                           0x0, 0x0);
1546         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1547 
1548         return true;
1549     } else if (coex_sta->pan_exist) {
1550         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1551             "[BTCoex], Wifi  idle process for BT PAN exist!!\n");
1552 
1553         btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1554         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1555 
1556         /* sw all off */
1557         btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1558                        false);
1559         btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1560                        0x18);
1561 
1562         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1563         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1564                           0x0, 0x0);
1565         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1566 
1567         return true;
1568     }
1569     btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1570     return false;
1571 }
1572 
1573 static bool btc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
1574 {
1575     struct rtl_priv *rtlpriv = btcoexist->adapter;
1576     bool common = false, wifi_connected = false, wifi_busy = false;
1577     bool low_pwr_disable = false;
1578     bool bt_hs_on = false;
1579 
1580     btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1581     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1582                &wifi_connected);
1583     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1584 
1585     if (!wifi_connected) {
1586         low_pwr_disable = false;
1587         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1588                    &low_pwr_disable);
1589         btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
1590                     0x8);
1591 
1592         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1593             "[BTCoex], Wifi non-connected idle!!\n");
1594 
1595         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1596                       0x0);
1597         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1598         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1599                           0x0, 0x0);
1600         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1601         btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1602         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1603 
1604         btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1605                        false);
1606         btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1607                        0x18);
1608 
1609         common = true;
1610     } else {
1611         if (BT_8821A_2ANT_BT_STATUS_IDLE ==
1612             coex_dm->bt_status) {
1613             low_pwr_disable = false;
1614             btcoexist->btc_set(btcoexist,
1615                        BTC_SET_ACT_DISABLE_LOW_POWER,
1616                        &low_pwr_disable);
1617             btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC,
1618                         false, false, 0x8);
1619 
1620             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1621                 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1622 
1623             btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1624                           0xfffff, 0x0);
1625             btc8821a2ant_coex_table_with_type(btcoexist,
1626                               NORMAL_EXEC, 0);
1627 
1628             btc8821a2ant_power_save_state(
1629                 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1630             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1631             btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1632                               0xb);
1633             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1634 
1635             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
1636                            false, false);
1637             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
1638                            false, 0x18);
1639 
1640             common = true;
1641         } else if (BT_8821A_2ANT_BT_STATUS_CON_IDLE ==
1642                coex_dm->bt_status) {
1643             low_pwr_disable = true;
1644             btcoexist->btc_set(btcoexist,
1645                        BTC_SET_ACT_DISABLE_LOW_POWER,
1646                        &low_pwr_disable);
1647 
1648             if (bt_hs_on)
1649                 return false;
1650             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1651                 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1652             btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC,
1653                         false, false, 0x8);
1654 
1655             btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1656                           0xfffff, 0x0);
1657             btc8821a2ant_coex_table_with_type(btcoexist,
1658                               NORMAL_EXEC, 0);
1659 
1660             btc8821a2ant_power_save_state(
1661                 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1662             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1663             btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1664                               0xb);
1665             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1666 
1667             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
1668                            false, false);
1669             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
1670                            false, 0x18);
1671             common = true;
1672         } else {
1673             low_pwr_disable = true;
1674             btcoexist->btc_set(btcoexist,
1675                        BTC_SET_ACT_DISABLE_LOW_POWER,
1676                        &low_pwr_disable);
1677 
1678             if (wifi_busy) {
1679                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1680                     "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1681                 common = false;
1682             } else {
1683                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1684                     "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1685                 common =
1686                     btc8821a2ant_action_wifi_idle_process(
1687                          btcoexist);
1688             }
1689         }
1690     }
1691     return common;
1692 }
1693 
1694 static void btc8821a2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
1695                           bool sco_hid, bool tx_pause,
1696                           u8 max_interval)
1697 {
1698     struct rtl_priv *rtlpriv = btcoexist->adapter;
1699     static long up, dn, m, n, wait_count;
1700      /* 0 : no change
1701       * +1: increase WiFi duration
1702       * -1: decrease WiFi duration
1703       */
1704     int result;
1705     u8 retry_count = 0;
1706 
1707     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1708         "[BTCoex], TdmaDurationAdjust()\n");
1709 
1710     if (coex_dm->auto_tdma_adjust) {
1711         coex_dm->auto_tdma_adjust = false;
1712         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1713             "[BTCoex], first run TdmaDurationAdjust()!!\n");
1714         if (sco_hid) {
1715             if (tx_pause) {
1716                 if (max_interval == 1) {
1717                     btc8821a2ant_ps_tdma(btcoexist,
1718                             NORMAL_EXEC, true, 13);
1719                     coex_dm->ps_tdma_du_adj_type = 13;
1720                 } else if (max_interval == 2) {
1721                     btc8821a2ant_ps_tdma(btcoexist,
1722                             NORMAL_EXEC, true, 14);
1723                     coex_dm->ps_tdma_du_adj_type = 14;
1724                 } else {
1725                     btc8821a2ant_ps_tdma(btcoexist,
1726                             NORMAL_EXEC, true, 15);
1727                     coex_dm->ps_tdma_du_adj_type = 15;
1728                 }
1729             } else {
1730                 if (max_interval == 1) {
1731                     btc8821a2ant_ps_tdma(btcoexist,
1732                             NORMAL_EXEC, true, 9);
1733                     coex_dm->ps_tdma_du_adj_type = 9;
1734                 } else if (max_interval == 2) {
1735                     btc8821a2ant_ps_tdma(btcoexist,
1736                             NORMAL_EXEC, true, 10);
1737                     coex_dm->ps_tdma_du_adj_type = 10;
1738                 } else {
1739                     btc8821a2ant_ps_tdma(btcoexist,
1740                             NORMAL_EXEC, true, 11);
1741                     coex_dm->ps_tdma_du_adj_type = 11;
1742                 }
1743             }
1744         } else {
1745             if (tx_pause) {
1746                 if (max_interval == 1) {
1747                     btc8821a2ant_ps_tdma(btcoexist,
1748                             NORMAL_EXEC, true, 5);
1749                     coex_dm->ps_tdma_du_adj_type = 5;
1750                 } else if (max_interval == 2) {
1751                     btc8821a2ant_ps_tdma(btcoexist,
1752                             NORMAL_EXEC, true, 6);
1753                     coex_dm->ps_tdma_du_adj_type = 6;
1754                 } else {
1755                     btc8821a2ant_ps_tdma(btcoexist,
1756                             NORMAL_EXEC, true, 7);
1757                     coex_dm->ps_tdma_du_adj_type = 7;
1758                 }
1759             } else {
1760                 if (max_interval == 1) {
1761                     btc8821a2ant_ps_tdma(btcoexist,
1762                             NORMAL_EXEC, true, 1);
1763                     coex_dm->ps_tdma_du_adj_type = 1;
1764                 } else if (max_interval == 2) {
1765                     btc8821a2ant_ps_tdma(btcoexist,
1766                             NORMAL_EXEC, true, 2);
1767                     coex_dm->ps_tdma_du_adj_type = 2;
1768                 } else {
1769                     btc8821a2ant_ps_tdma(btcoexist,
1770                             NORMAL_EXEC, true, 3);
1771                     coex_dm->ps_tdma_du_adj_type = 3;
1772                 }
1773             }
1774         }
1775 
1776         up = 0;
1777         dn = 0;
1778         m = 1;
1779         n = 3;
1780         result = 0;
1781         wait_count = 0;
1782     } else {
1783         /* accquire the BT TRx retry count from BT_Info byte2 */
1784         retry_count = coex_sta->bt_retry_cnt;
1785         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1786             "[BTCoex], retry_count = %d\n", retry_count);
1787         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1788             "[BTCoex], up = %d, dn = %d, m = %d, n = %d, wait_count = %d\n",
1789             (int)up, (int)dn, (int)m, (int)n, (int)wait_count);
1790         result = 0;
1791         wait_count++;
1792 
1793         if (retry_count == 0) {
1794             /* no retry in the last 2-second duration */
1795             up++;
1796             dn--;
1797 
1798             if (dn <= 0)
1799                 dn = 0;
1800 
1801             if (up >= n) {
1802                 /* if (retry count == 0) for 2*n seconds,
1803                  * make WiFi duration wider
1804                  */
1805                 wait_count = 0;
1806                 n = 3;
1807                 up = 0;
1808                 dn = 0;
1809                 result = 1;
1810                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1811                     "[BTCoex], Increase wifi duration!!\n");
1812             }
1813         } else if (retry_count <= 3) {
1814             /* <=3 retry in the last 2-second duration */
1815             up--;
1816             dn++;
1817 
1818             if (up <= 0)
1819                 up = 0;
1820 
1821             if (dn == 2) {
1822                 /* if retry count < 3 for 2*2 seconds,
1823                  * shrink wifi duration
1824                  */
1825                 if (wait_count <= 2)
1826                     m++; /* avoid bounce in two levels */
1827                 else
1828                     m = 1;
1829                 /* m max value is 20, max time is 120 second,
1830                  * recheck if adjust WiFi duration.
1831                  */
1832                 if (m >= 20)
1833                     m = 20;
1834 
1835                 n = 3 * m;
1836                 up = 0;
1837                 dn = 0;
1838                 wait_count = 0;
1839                 result = -1;
1840                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1841                     "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1842             }
1843         } else {
1844             /* retry count > 3, if retry count > 3 happens once,
1845              * shrink WiFi duration
1846              */
1847             if (wait_count == 1)
1848                 m++; /* avoid bounce in two levels */
1849             else
1850                 m = 1;
1851             /* m max value is 20, max time is 120 second,
1852              * recheck if adjust WiFi duration.
1853              */
1854             if (m >= 20)
1855                 m = 20;
1856 
1857             n = 3 * m;
1858             up = 0;
1859             dn = 0;
1860             wait_count = 0;
1861             result = -1;
1862             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1863                 "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1864         }
1865 
1866         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1867             "[BTCoex], max Interval = %d\n", max_interval);
1868 
1869         if (max_interval == 1) {
1870             if (tx_pause) {
1871                 if (coex_dm->cur_ps_tdma == 71) {
1872                     btc8821a2ant_ps_tdma(btcoexist,
1873                             NORMAL_EXEC, true, 5);
1874                     coex_dm->ps_tdma_du_adj_type = 5;
1875                 } else if (coex_dm->cur_ps_tdma == 1) {
1876                     btc8821a2ant_ps_tdma(btcoexist,
1877                             NORMAL_EXEC, true, 5);
1878                     coex_dm->ps_tdma_du_adj_type = 5;
1879                 } else if (coex_dm->cur_ps_tdma == 2) {
1880                     btc8821a2ant_ps_tdma(btcoexist,
1881                             NORMAL_EXEC, true, 6);
1882                     coex_dm->ps_tdma_du_adj_type = 6;
1883                 } else if (coex_dm->cur_ps_tdma == 3) {
1884                     btc8821a2ant_ps_tdma(btcoexist,
1885                             NORMAL_EXEC, true, 7);
1886                     coex_dm->ps_tdma_du_adj_type = 7;
1887                 } else if (coex_dm->cur_ps_tdma == 4) {
1888                     btc8821a2ant_ps_tdma(btcoexist,
1889                             NORMAL_EXEC, true, 8);
1890                     coex_dm->ps_tdma_du_adj_type = 8;
1891                 }
1892                 if (coex_dm->cur_ps_tdma == 9) {
1893                     btc8821a2ant_ps_tdma(btcoexist,
1894                             NORMAL_EXEC, true, 13);
1895                     coex_dm->ps_tdma_du_adj_type = 13;
1896                 } else if (coex_dm->cur_ps_tdma == 10) {
1897                     btc8821a2ant_ps_tdma(btcoexist,
1898                             NORMAL_EXEC, true, 14);
1899                     coex_dm->ps_tdma_du_adj_type = 14;
1900                 } else if (coex_dm->cur_ps_tdma == 11) {
1901                     btc8821a2ant_ps_tdma(btcoexist,
1902                             NORMAL_EXEC, true, 15);
1903                     coex_dm->ps_tdma_du_adj_type = 15;
1904                 } else if (coex_dm->cur_ps_tdma == 12) {
1905                     btc8821a2ant_ps_tdma(btcoexist,
1906                             NORMAL_EXEC, true, 16);
1907                     coex_dm->ps_tdma_du_adj_type = 16;
1908                 }
1909 
1910                 if (result == -1) {
1911                     if (coex_dm->cur_ps_tdma == 5) {
1912                         btc8821a2ant_ps_tdma(
1913                             btcoexist, NORMAL_EXEC,
1914                             true, 6);
1915                         coex_dm->ps_tdma_du_adj_type =
1916                             6;
1917                     } else if (coex_dm->cur_ps_tdma == 6) {
1918                         btc8821a2ant_ps_tdma(
1919                             btcoexist, NORMAL_EXEC,
1920                             true, 7);
1921                         coex_dm->ps_tdma_du_adj_type =
1922                             7;
1923                     } else if (coex_dm->cur_ps_tdma == 7) {
1924                         btc8821a2ant_ps_tdma(
1925                             btcoexist, NORMAL_EXEC,
1926                             true, 8);
1927                         coex_dm->ps_tdma_du_adj_type =
1928                             8;
1929                     } else if (coex_dm->cur_ps_tdma == 13) {
1930                         btc8821a2ant_ps_tdma(
1931                             btcoexist, NORMAL_EXEC,
1932                             true, 14);
1933                         coex_dm->ps_tdma_du_adj_type =
1934                             14;
1935                     } else if (coex_dm->cur_ps_tdma == 14) {
1936                         btc8821a2ant_ps_tdma(
1937                             btcoexist, NORMAL_EXEC,
1938                             true, 15);
1939                         coex_dm->ps_tdma_du_adj_type =
1940                             15;
1941                     } else if (coex_dm->cur_ps_tdma == 15) {
1942                         btc8821a2ant_ps_tdma(
1943                             btcoexist, NORMAL_EXEC,
1944                             true, 16);
1945                         coex_dm->ps_tdma_du_adj_type =
1946                             16;
1947                     }
1948                 } else if (result == 1) {
1949                     if (coex_dm->cur_ps_tdma == 8) {
1950                         btc8821a2ant_ps_tdma(
1951                             btcoexist, NORMAL_EXEC,
1952                             true, 7);
1953                         coex_dm->ps_tdma_du_adj_type =
1954                             7;
1955                     } else if (coex_dm->cur_ps_tdma == 7) {
1956                         btc8821a2ant_ps_tdma(
1957                             btcoexist, NORMAL_EXEC,
1958                             true, 6);
1959                         coex_dm->ps_tdma_du_adj_type =
1960                             6;
1961                     } else if (coex_dm->cur_ps_tdma == 6) {
1962                         btc8821a2ant_ps_tdma(
1963                             btcoexist, NORMAL_EXEC,
1964                             true, 5);
1965                         coex_dm->ps_tdma_du_adj_type =
1966                             5;
1967                     } else if (coex_dm->cur_ps_tdma == 16) {
1968                         btc8821a2ant_ps_tdma(
1969                             btcoexist, NORMAL_EXEC,
1970                             true, 15);
1971                         coex_dm->ps_tdma_du_adj_type =
1972                             15;
1973                     } else if (coex_dm->cur_ps_tdma == 15) {
1974                         btc8821a2ant_ps_tdma(
1975                             btcoexist, NORMAL_EXEC,
1976                             true, 14);
1977                         coex_dm->ps_tdma_du_adj_type =
1978                             14;
1979                     } else if (coex_dm->cur_ps_tdma == 14) {
1980                         btc8821a2ant_ps_tdma(
1981                             btcoexist, NORMAL_EXEC,
1982                             true, 13);
1983                         coex_dm->ps_tdma_du_adj_type =
1984                             13;
1985                     }
1986                 }
1987             } else {
1988                 if (coex_dm->cur_ps_tdma == 5) {
1989                     btc8821a2ant_ps_tdma(btcoexist,
1990                             NORMAL_EXEC, true, 71);
1991                     coex_dm->ps_tdma_du_adj_type = 71;
1992                 } else if (coex_dm->cur_ps_tdma == 6) {
1993                     btc8821a2ant_ps_tdma(btcoexist,
1994                             NORMAL_EXEC, true, 2);
1995                     coex_dm->ps_tdma_du_adj_type = 2;
1996                 } else if (coex_dm->cur_ps_tdma == 7) {
1997                     btc8821a2ant_ps_tdma(btcoexist,
1998                             NORMAL_EXEC, true, 3);
1999                     coex_dm->ps_tdma_du_adj_type = 3;
2000                 } else if (coex_dm->cur_ps_tdma == 8) {
2001                     btc8821a2ant_ps_tdma(btcoexist,
2002                             NORMAL_EXEC, true, 4);
2003                     coex_dm->ps_tdma_du_adj_type = 4;
2004                 }
2005                 if (coex_dm->cur_ps_tdma == 13) {
2006                     btc8821a2ant_ps_tdma(btcoexist,
2007                             NORMAL_EXEC, true, 9);
2008                     coex_dm->ps_tdma_du_adj_type = 9;
2009                 } else if (coex_dm->cur_ps_tdma == 14) {
2010                     btc8821a2ant_ps_tdma(btcoexist,
2011                             NORMAL_EXEC, true, 10);
2012                     coex_dm->ps_tdma_du_adj_type = 10;
2013                 } else if (coex_dm->cur_ps_tdma == 15) {
2014                     btc8821a2ant_ps_tdma(btcoexist,
2015                             NORMAL_EXEC, true, 11);
2016                     coex_dm->ps_tdma_du_adj_type = 11;
2017                 } else if (coex_dm->cur_ps_tdma == 16) {
2018                     btc8821a2ant_ps_tdma(btcoexist,
2019                             NORMAL_EXEC, true, 12);
2020                     coex_dm->ps_tdma_du_adj_type = 12;
2021                 }
2022 
2023                 if (result == -1) {
2024                     if (coex_dm->cur_ps_tdma == 71) {
2025                         btc8821a2ant_ps_tdma(
2026                             btcoexist, NORMAL_EXEC,
2027                             true, 1);
2028                         coex_dm->ps_tdma_du_adj_type =
2029                             1;
2030                     } else if (coex_dm->cur_ps_tdma == 1) {
2031                         btc8821a2ant_ps_tdma(
2032                             btcoexist, NORMAL_EXEC,
2033                             true, 2);
2034                         coex_dm->ps_tdma_du_adj_type =
2035                             2;
2036                     } else if (coex_dm->cur_ps_tdma == 2) {
2037                         btc8821a2ant_ps_tdma(
2038                             btcoexist, NORMAL_EXEC,
2039                             true, 3);
2040                         coex_dm->ps_tdma_du_adj_type =
2041                             3;
2042                     } else if (coex_dm->cur_ps_tdma == 3) {
2043                         btc8821a2ant_ps_tdma(
2044                             btcoexist, NORMAL_EXEC,
2045                             true, 4);
2046                         coex_dm->ps_tdma_du_adj_type =
2047                             4;
2048                     } else if (coex_dm->cur_ps_tdma == 9) {
2049                         btc8821a2ant_ps_tdma(
2050                             btcoexist, NORMAL_EXEC,
2051                             true, 10);
2052                         coex_dm->ps_tdma_du_adj_type =
2053                             10;
2054                     } else if (coex_dm->cur_ps_tdma == 10) {
2055                         btc8821a2ant_ps_tdma(
2056                             btcoexist, NORMAL_EXEC,
2057                             true, 11);
2058                         coex_dm->ps_tdma_du_adj_type =
2059                             11;
2060                     } else if (coex_dm->cur_ps_tdma == 11) {
2061                         btc8821a2ant_ps_tdma(
2062                             btcoexist, NORMAL_EXEC,
2063                             true, 12);
2064                         coex_dm->ps_tdma_du_adj_type =
2065                             12;
2066                     }
2067                 } else if (result == 1) {
2068                     if (coex_dm->cur_ps_tdma == 4) {
2069                         btc8821a2ant_ps_tdma(
2070                             btcoexist, NORMAL_EXEC,
2071                             true, 3);
2072                         coex_dm->ps_tdma_du_adj_type =
2073                             3;
2074                     } else if (coex_dm->cur_ps_tdma == 3) {
2075                         btc8821a2ant_ps_tdma(
2076                             btcoexist, NORMAL_EXEC,
2077                             true, 2);
2078                         coex_dm->ps_tdma_du_adj_type =
2079                             2;
2080                     } else if (coex_dm->cur_ps_tdma == 2) {
2081                         btc8821a2ant_ps_tdma(
2082                             btcoexist, NORMAL_EXEC,
2083                             true, 1);
2084                         coex_dm->ps_tdma_du_adj_type =
2085                             1;
2086                     } else if (coex_dm->cur_ps_tdma == 1) {
2087                         btc8821a2ant_ps_tdma(
2088                             btcoexist, NORMAL_EXEC,
2089                             true, 71);
2090                         coex_dm->ps_tdma_du_adj_type =
2091                             71;
2092                     } else if (coex_dm->cur_ps_tdma == 12) {
2093                         btc8821a2ant_ps_tdma(
2094                             btcoexist, NORMAL_EXEC,
2095                             true, 11);
2096                         coex_dm->ps_tdma_du_adj_type =
2097                             11;
2098                     } else if (coex_dm->cur_ps_tdma == 11) {
2099                         btc8821a2ant_ps_tdma(
2100                             btcoexist, NORMAL_EXEC,
2101                             true, 10);
2102                         coex_dm->ps_tdma_du_adj_type =
2103                             10;
2104                     } else if (coex_dm->cur_ps_tdma == 10) {
2105                         btc8821a2ant_ps_tdma(
2106                             btcoexist, NORMAL_EXEC,
2107                             true, 9);
2108                         coex_dm->ps_tdma_du_adj_type =
2109                             9;
2110                     }
2111                 }
2112             }
2113         } else if (max_interval == 2) {
2114             if (tx_pause) {
2115                 if (coex_dm->cur_ps_tdma == 1) {
2116                     btc8821a2ant_ps_tdma(btcoexist,
2117                             NORMAL_EXEC, true, 6);
2118                     coex_dm->ps_tdma_du_adj_type = 6;
2119                 } else if (coex_dm->cur_ps_tdma == 2) {
2120                     btc8821a2ant_ps_tdma(btcoexist,
2121                             NORMAL_EXEC, true, 6);
2122                     coex_dm->ps_tdma_du_adj_type = 6;
2123                 } else if (coex_dm->cur_ps_tdma == 3) {
2124                     btc8821a2ant_ps_tdma(btcoexist,
2125                             NORMAL_EXEC, true, 7);
2126                     coex_dm->ps_tdma_du_adj_type = 7;
2127                 } else if (coex_dm->cur_ps_tdma == 4) {
2128                     btc8821a2ant_ps_tdma(btcoexist,
2129                             NORMAL_EXEC, true, 8);
2130                     coex_dm->ps_tdma_du_adj_type = 8;
2131                 }
2132                 if (coex_dm->cur_ps_tdma == 9) {
2133                     btc8821a2ant_ps_tdma(btcoexist,
2134                             NORMAL_EXEC, true, 14);
2135                     coex_dm->ps_tdma_du_adj_type = 14;
2136                 } else if (coex_dm->cur_ps_tdma == 10) {
2137                     btc8821a2ant_ps_tdma(btcoexist,
2138                             NORMAL_EXEC, true, 14);
2139                     coex_dm->ps_tdma_du_adj_type = 14;
2140                 } else if (coex_dm->cur_ps_tdma == 11) {
2141                     btc8821a2ant_ps_tdma(btcoexist,
2142                             NORMAL_EXEC, true, 15);
2143                     coex_dm->ps_tdma_du_adj_type = 15;
2144                 } else if (coex_dm->cur_ps_tdma == 12) {
2145                     btc8821a2ant_ps_tdma(btcoexist,
2146                             NORMAL_EXEC, true, 16);
2147                     coex_dm->ps_tdma_du_adj_type = 16;
2148                 }
2149                 if (result == -1) {
2150                     if (coex_dm->cur_ps_tdma == 5) {
2151                         btc8821a2ant_ps_tdma(
2152                             btcoexist, NORMAL_EXEC,
2153                             true, 6);
2154                         coex_dm->ps_tdma_du_adj_type =
2155                             6;
2156                     } else if (coex_dm->cur_ps_tdma == 6) {
2157                         btc8821a2ant_ps_tdma(
2158                             btcoexist, NORMAL_EXEC,
2159                             true, 7);
2160                         coex_dm->ps_tdma_du_adj_type =
2161                             7;
2162                     } else if (coex_dm->cur_ps_tdma == 7) {
2163                         btc8821a2ant_ps_tdma(
2164                             btcoexist, NORMAL_EXEC,
2165                             true, 8);
2166                         coex_dm->ps_tdma_du_adj_type =
2167                             8;
2168                     } else if (coex_dm->cur_ps_tdma == 13) {
2169                         btc8821a2ant_ps_tdma(
2170                             btcoexist, NORMAL_EXEC,
2171                             true, 14);
2172                         coex_dm->ps_tdma_du_adj_type =
2173                             14;
2174                     } else if (coex_dm->cur_ps_tdma == 14) {
2175                         btc8821a2ant_ps_tdma(
2176                             btcoexist, NORMAL_EXEC,
2177                             true, 15);
2178                         coex_dm->ps_tdma_du_adj_type =
2179                             15;
2180                     } else if (coex_dm->cur_ps_tdma == 15) {
2181                         btc8821a2ant_ps_tdma(
2182                             btcoexist, NORMAL_EXEC,
2183                             true, 16);
2184                         coex_dm->ps_tdma_du_adj_type =
2185                             16;
2186                     }
2187                 } else if (result == 1) {
2188                     if (coex_dm->cur_ps_tdma == 8) {
2189                         btc8821a2ant_ps_tdma(
2190                             btcoexist, NORMAL_EXEC,
2191                             true, 7);
2192                         coex_dm->ps_tdma_du_adj_type =
2193                             7;
2194                     } else if (coex_dm->cur_ps_tdma == 7) {
2195                         btc8821a2ant_ps_tdma(
2196                             btcoexist, NORMAL_EXEC,
2197                             true, 6);
2198                         coex_dm->ps_tdma_du_adj_type =
2199                             6;
2200                     } else if (coex_dm->cur_ps_tdma == 6) {
2201                         btc8821a2ant_ps_tdma(
2202                             btcoexist, NORMAL_EXEC,
2203                             true, 6);
2204                         coex_dm->ps_tdma_du_adj_type =
2205                             6;
2206                     } else if (coex_dm->cur_ps_tdma == 16) {
2207                         btc8821a2ant_ps_tdma(
2208                             btcoexist, NORMAL_EXEC,
2209                             true, 15);
2210                         coex_dm->ps_tdma_du_adj_type =
2211                             15;
2212                     } else if (coex_dm->cur_ps_tdma == 15) {
2213                         btc8821a2ant_ps_tdma(
2214                             btcoexist, NORMAL_EXEC,
2215                             true, 14);
2216                         coex_dm->ps_tdma_du_adj_type =
2217                             14;
2218                     } else if (coex_dm->cur_ps_tdma == 14) {
2219                         btc8821a2ant_ps_tdma(
2220                             btcoexist, NORMAL_EXEC,
2221                             true, 14);
2222                         coex_dm->ps_tdma_du_adj_type =
2223                             14;
2224                     }
2225                 }
2226             } else {
2227                 if (coex_dm->cur_ps_tdma == 5) {
2228                     btc8821a2ant_ps_tdma(btcoexist,
2229                             NORMAL_EXEC, true, 2);
2230                     coex_dm->ps_tdma_du_adj_type = 2;
2231                 } else if (coex_dm->cur_ps_tdma == 6) {
2232                     btc8821a2ant_ps_tdma(btcoexist,
2233                             NORMAL_EXEC, true, 2);
2234                     coex_dm->ps_tdma_du_adj_type = 2;
2235                 } else if (coex_dm->cur_ps_tdma == 7) {
2236                     btc8821a2ant_ps_tdma(btcoexist,
2237                             NORMAL_EXEC, true, 3);
2238                     coex_dm->ps_tdma_du_adj_type = 3;
2239                 } else if (coex_dm->cur_ps_tdma == 8) {
2240                     btc8821a2ant_ps_tdma(btcoexist,
2241                             NORMAL_EXEC, true, 4);
2242                     coex_dm->ps_tdma_du_adj_type = 4;
2243                 }
2244                 if (coex_dm->cur_ps_tdma == 13) {
2245                     btc8821a2ant_ps_tdma(btcoexist,
2246                             NORMAL_EXEC, true, 10);
2247                     coex_dm->ps_tdma_du_adj_type = 10;
2248                 } else if (coex_dm->cur_ps_tdma == 14) {
2249                     btc8821a2ant_ps_tdma(btcoexist,
2250                             NORMAL_EXEC, true, 10);
2251                     coex_dm->ps_tdma_du_adj_type = 10;
2252                 } else if (coex_dm->cur_ps_tdma == 15) {
2253                     btc8821a2ant_ps_tdma(btcoexist,
2254                             NORMAL_EXEC, true, 11);
2255                     coex_dm->ps_tdma_du_adj_type = 11;
2256                 } else if (coex_dm->cur_ps_tdma == 16) {
2257                     btc8821a2ant_ps_tdma(btcoexist,
2258                             NORMAL_EXEC, true, 12);
2259                     coex_dm->ps_tdma_du_adj_type = 12;
2260                 }
2261                 if (result == -1) {
2262                     if (coex_dm->cur_ps_tdma == 1) {
2263                         btc8821a2ant_ps_tdma(
2264                             btcoexist, NORMAL_EXEC,
2265                             true, 2);
2266                         coex_dm->ps_tdma_du_adj_type =
2267                             2;
2268                     } else if (coex_dm->cur_ps_tdma == 2) {
2269                         btc8821a2ant_ps_tdma(
2270                             btcoexist, NORMAL_EXEC,
2271                             true, 3);
2272                         coex_dm->ps_tdma_du_adj_type =
2273                             3;
2274                     } else if (coex_dm->cur_ps_tdma == 3) {
2275                         btc8821a2ant_ps_tdma(
2276                             btcoexist, NORMAL_EXEC,
2277                             true, 4);
2278                         coex_dm->ps_tdma_du_adj_type =
2279                             4;
2280                     } else if (coex_dm->cur_ps_tdma == 9) {
2281                         btc8821a2ant_ps_tdma(
2282                             btcoexist, NORMAL_EXEC,
2283                             true, 10);
2284                         coex_dm->ps_tdma_du_adj_type =
2285                             10;
2286                     } else if (coex_dm->cur_ps_tdma == 10) {
2287                         btc8821a2ant_ps_tdma(
2288                             btcoexist, NORMAL_EXEC,
2289                             true, 11);
2290                         coex_dm->ps_tdma_du_adj_type =
2291                             11;
2292                     } else if (coex_dm->cur_ps_tdma == 11) {
2293                         btc8821a2ant_ps_tdma(
2294                             btcoexist, NORMAL_EXEC,
2295                             true, 12);
2296                         coex_dm->ps_tdma_du_adj_type =
2297                             12;
2298                     }
2299                 } else if (result == 1) {
2300                     if (coex_dm->cur_ps_tdma == 4) {
2301                         btc8821a2ant_ps_tdma(
2302                             btcoexist, NORMAL_EXEC,
2303                             true, 3);
2304                         coex_dm->ps_tdma_du_adj_type =
2305                             3;
2306                     } else if (coex_dm->cur_ps_tdma == 3) {
2307                         btc8821a2ant_ps_tdma(
2308                             btcoexist, NORMAL_EXEC,
2309                             true, 2);
2310                         coex_dm->ps_tdma_du_adj_type =
2311                             2;
2312                     } else if (coex_dm->cur_ps_tdma == 2) {
2313                         btc8821a2ant_ps_tdma(
2314                             btcoexist, NORMAL_EXEC,
2315                             true, 2);
2316                         coex_dm->ps_tdma_du_adj_type =
2317                             2;
2318                     } else if (coex_dm->cur_ps_tdma == 12) {
2319                         btc8821a2ant_ps_tdma(
2320                             btcoexist, NORMAL_EXEC,
2321                             true, 11);
2322                         coex_dm->ps_tdma_du_adj_type =
2323                             11;
2324                     } else if (coex_dm->cur_ps_tdma == 11) {
2325                         btc8821a2ant_ps_tdma(
2326                             btcoexist, NORMAL_EXEC,
2327                             true, 10);
2328                         coex_dm->ps_tdma_du_adj_type =
2329                             10;
2330                     } else if (coex_dm->cur_ps_tdma == 10) {
2331                         btc8821a2ant_ps_tdma(
2332                             btcoexist, NORMAL_EXEC,
2333                             true, 10);
2334                         coex_dm->ps_tdma_du_adj_type =
2335                             10;
2336                     }
2337                 }
2338             }
2339         } else if (max_interval == 3) {
2340             if (tx_pause) {
2341                 if (coex_dm->cur_ps_tdma == 1) {
2342                     btc8821a2ant_ps_tdma(btcoexist,
2343                             NORMAL_EXEC, true, 7);
2344                     coex_dm->ps_tdma_du_adj_type = 7;
2345                 } else if (coex_dm->cur_ps_tdma == 2) {
2346                     btc8821a2ant_ps_tdma(btcoexist,
2347                             NORMAL_EXEC, true, 7);
2348                     coex_dm->ps_tdma_du_adj_type = 7;
2349                 } else if (coex_dm->cur_ps_tdma == 3) {
2350                     btc8821a2ant_ps_tdma(btcoexist,
2351                             NORMAL_EXEC, true, 7);
2352                     coex_dm->ps_tdma_du_adj_type = 7;
2353                 } else if (coex_dm->cur_ps_tdma == 4) {
2354                     btc8821a2ant_ps_tdma(btcoexist,
2355                             NORMAL_EXEC, true, 8);
2356                     coex_dm->ps_tdma_du_adj_type = 8;
2357                 }
2358                 if (coex_dm->cur_ps_tdma == 9) {
2359                     btc8821a2ant_ps_tdma(btcoexist,
2360                             NORMAL_EXEC, true, 15);
2361                     coex_dm->ps_tdma_du_adj_type = 15;
2362                 } else if (coex_dm->cur_ps_tdma == 10) {
2363                     btc8821a2ant_ps_tdma(btcoexist,
2364                             NORMAL_EXEC, true, 15);
2365                     coex_dm->ps_tdma_du_adj_type = 15;
2366                 } else if (coex_dm->cur_ps_tdma == 11) {
2367                     btc8821a2ant_ps_tdma(btcoexist,
2368                             NORMAL_EXEC, true, 15);
2369                     coex_dm->ps_tdma_du_adj_type = 15;
2370                 } else if (coex_dm->cur_ps_tdma == 12) {
2371                     btc8821a2ant_ps_tdma(btcoexist,
2372                             NORMAL_EXEC, true, 16);
2373                     coex_dm->ps_tdma_du_adj_type = 16;
2374                 }
2375                 if (result == -1) {
2376                     if (coex_dm->cur_ps_tdma == 5) {
2377                         btc8821a2ant_ps_tdma(
2378                             btcoexist, NORMAL_EXEC,
2379                             true, 7);
2380                         coex_dm->ps_tdma_du_adj_type =
2381                             7;
2382                     } else if (coex_dm->cur_ps_tdma == 6) {
2383                         btc8821a2ant_ps_tdma(
2384                             btcoexist, NORMAL_EXEC,
2385                             true, 7);
2386                         coex_dm->ps_tdma_du_adj_type =
2387                             7;
2388                     } else if (coex_dm->cur_ps_tdma == 7) {
2389                         btc8821a2ant_ps_tdma(
2390                             btcoexist, NORMAL_EXEC,
2391                             true, 8);
2392                         coex_dm->ps_tdma_du_adj_type =
2393                             8;
2394                     } else if (coex_dm->cur_ps_tdma == 13) {
2395                         btc8821a2ant_ps_tdma(
2396                             btcoexist, NORMAL_EXEC,
2397                             true, 15);
2398                         coex_dm->ps_tdma_du_adj_type =
2399                             15;
2400                     } else if (coex_dm->cur_ps_tdma == 14) {
2401                         btc8821a2ant_ps_tdma(
2402                             btcoexist, NORMAL_EXEC,
2403                             true, 15);
2404                         coex_dm->ps_tdma_du_adj_type =
2405                             15;
2406                     } else if (coex_dm->cur_ps_tdma == 15) {
2407                         btc8821a2ant_ps_tdma(
2408                             btcoexist, NORMAL_EXEC,
2409                             true, 16);
2410                         coex_dm->ps_tdma_du_adj_type =
2411                             16;
2412                     }
2413                 } else if (result == 1) {
2414                     if (coex_dm->cur_ps_tdma == 8) {
2415                         btc8821a2ant_ps_tdma(
2416                             btcoexist, NORMAL_EXEC,
2417                             true, 7);
2418                         coex_dm->ps_tdma_du_adj_type =
2419                             7;
2420                     } else if (coex_dm->cur_ps_tdma == 7) {
2421                         btc8821a2ant_ps_tdma(
2422                             btcoexist, NORMAL_EXEC,
2423                             true, 7);
2424                         coex_dm->ps_tdma_du_adj_type =
2425                             7;
2426                     } else if (coex_dm->cur_ps_tdma == 6) {
2427                         btc8821a2ant_ps_tdma(
2428                             btcoexist, NORMAL_EXEC,
2429                             true, 7);
2430                         coex_dm->ps_tdma_du_adj_type =
2431                             7;
2432                     } else if (coex_dm->cur_ps_tdma == 16) {
2433                         btc8821a2ant_ps_tdma(
2434                             btcoexist, NORMAL_EXEC,
2435                             true, 15);
2436                         coex_dm->ps_tdma_du_adj_type =
2437                             15;
2438                     } else if (coex_dm->cur_ps_tdma == 15) {
2439                         btc8821a2ant_ps_tdma(
2440                             btcoexist, NORMAL_EXEC,
2441                             true, 15);
2442                         coex_dm->ps_tdma_du_adj_type =
2443                             15;
2444                     } else if (coex_dm->cur_ps_tdma == 14) {
2445                         btc8821a2ant_ps_tdma(
2446                             btcoexist, NORMAL_EXEC,
2447                             true, 15);
2448                         coex_dm->ps_tdma_du_adj_type =
2449                             15;
2450                     }
2451                 }
2452             } else {
2453                 if (coex_dm->cur_ps_tdma == 5) {
2454                     btc8821a2ant_ps_tdma(btcoexist,
2455                             NORMAL_EXEC, true, 3);
2456                     coex_dm->ps_tdma_du_adj_type = 3;
2457                 } else if (coex_dm->cur_ps_tdma == 6) {
2458                     btc8821a2ant_ps_tdma(btcoexist,
2459                             NORMAL_EXEC, true, 3);
2460                     coex_dm->ps_tdma_du_adj_type = 3;
2461                 } else if (coex_dm->cur_ps_tdma == 7) {
2462                     btc8821a2ant_ps_tdma(btcoexist,
2463                             NORMAL_EXEC, true, 3);
2464                     coex_dm->ps_tdma_du_adj_type = 3;
2465                 } else if (coex_dm->cur_ps_tdma == 8) {
2466                     btc8821a2ant_ps_tdma(btcoexist,
2467                             NORMAL_EXEC, true, 4);
2468                     coex_dm->ps_tdma_du_adj_type = 4;
2469                 }
2470                 if (coex_dm->cur_ps_tdma == 13) {
2471                     btc8821a2ant_ps_tdma(btcoexist,
2472                             NORMAL_EXEC, true, 11);
2473                     coex_dm->ps_tdma_du_adj_type = 11;
2474                 } else if (coex_dm->cur_ps_tdma == 14) {
2475                     btc8821a2ant_ps_tdma(btcoexist,
2476                             NORMAL_EXEC, true, 11);
2477                     coex_dm->ps_tdma_du_adj_type = 11;
2478                 } else if (coex_dm->cur_ps_tdma == 15) {
2479                     btc8821a2ant_ps_tdma(btcoexist,
2480                             NORMAL_EXEC, true, 11);
2481                     coex_dm->ps_tdma_du_adj_type = 11;
2482                 } else if (coex_dm->cur_ps_tdma == 16) {
2483                     btc8821a2ant_ps_tdma(btcoexist,
2484                             NORMAL_EXEC, true, 12);
2485                     coex_dm->ps_tdma_du_adj_type = 12;
2486                 }
2487                 if (result == -1) {
2488                     if (coex_dm->cur_ps_tdma == 1) {
2489                         btc8821a2ant_ps_tdma(
2490                             btcoexist, NORMAL_EXEC,
2491                             true, 3);
2492                         coex_dm->ps_tdma_du_adj_type =
2493                             3;
2494                     } else if (coex_dm->cur_ps_tdma == 2) {
2495                         btc8821a2ant_ps_tdma(
2496                             btcoexist, NORMAL_EXEC,
2497                             true, 3);
2498                         coex_dm->ps_tdma_du_adj_type =
2499                             3;
2500                     } else if (coex_dm->cur_ps_tdma == 3) {
2501                         btc8821a2ant_ps_tdma(
2502                             btcoexist, NORMAL_EXEC,
2503                             true, 4);
2504                         coex_dm->ps_tdma_du_adj_type =
2505                             4;
2506                     } else if (coex_dm->cur_ps_tdma == 9) {
2507                         btc8821a2ant_ps_tdma(
2508                             btcoexist, NORMAL_EXEC,
2509                             true, 11);
2510                         coex_dm->ps_tdma_du_adj_type =
2511                             11;
2512                     } else if (coex_dm->cur_ps_tdma == 10) {
2513                         btc8821a2ant_ps_tdma(
2514                             btcoexist, NORMAL_EXEC,
2515                             true, 11);
2516                         coex_dm->ps_tdma_du_adj_type =
2517                             11;
2518                     } else if (coex_dm->cur_ps_tdma == 11) {
2519                         btc8821a2ant_ps_tdma(
2520                             btcoexist, NORMAL_EXEC,
2521                             true, 12);
2522                         coex_dm->ps_tdma_du_adj_type =
2523                             12;
2524                     }
2525                 } else if (result == 1) {
2526                     if (coex_dm->cur_ps_tdma == 4) {
2527                         btc8821a2ant_ps_tdma(
2528                             btcoexist, NORMAL_EXEC,
2529                             true, 3);
2530                         coex_dm->ps_tdma_du_adj_type =
2531                             3;
2532                     } else if (coex_dm->cur_ps_tdma == 3) {
2533                         btc8821a2ant_ps_tdma(
2534                             btcoexist, NORMAL_EXEC,
2535                             true, 3);
2536                         coex_dm->ps_tdma_du_adj_type =
2537                             3;
2538                     } else if (coex_dm->cur_ps_tdma == 2) {
2539                         btc8821a2ant_ps_tdma(
2540                             btcoexist, NORMAL_EXEC,
2541                             true, 3);
2542                         coex_dm->ps_tdma_du_adj_type =
2543                             3;
2544                     } else if (coex_dm->cur_ps_tdma == 12) {
2545                         btc8821a2ant_ps_tdma(
2546                             btcoexist, NORMAL_EXEC,
2547                             true, 11);
2548                         coex_dm->ps_tdma_du_adj_type =
2549                             11;
2550                     } else if (coex_dm->cur_ps_tdma == 11) {
2551                         btc8821a2ant_ps_tdma(
2552                             btcoexist, NORMAL_EXEC,
2553                             true, 11);
2554                         coex_dm->ps_tdma_du_adj_type =
2555                             11;
2556                     } else if (coex_dm->cur_ps_tdma == 10) {
2557                         btc8821a2ant_ps_tdma(
2558                             btcoexist, NORMAL_EXEC,
2559                             true, 11);
2560                         coex_dm->ps_tdma_du_adj_type =
2561                             11;
2562                     }
2563                 }
2564             }
2565         }
2566     }
2567 
2568     /* if current PsTdma not match with the recorded one
2569      * (when scan, dhcp...), then we have to adjust it back to
2570      * the previous recorded one.
2571      */
2572     if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2573         bool scan = false, link = false, roam = false;
2574 
2575         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2576             "[BTCoex], PsTdma type mismatch!!!, cur_ps_tdma = %d, recordPsTdma = %d\n",
2577             coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2578 
2579         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2580         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2581         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2582 
2583         if (!scan && !link && !roam) {
2584             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2585                          coex_dm->ps_tdma_du_adj_type);
2586         } else {
2587             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2588                 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2589         }
2590     }
2591 }
2592 
2593 /* SCO only or SCO+PAN(HS)*/
2594 static void btc8821a2ant_action_sco(struct btc_coexist *btcoexist)
2595 {
2596     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2597     u8 wifi_rssi_state, bt_rssi_state;
2598     u32 wifi_bw;
2599 
2600     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2601     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist, 2, 35, 0);
2602 
2603     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2604 
2605     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2606     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2607 
2608     if (BTC_RSSI_HIGH(bt_rssi_state))
2609         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2610     else
2611         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2612 
2613     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2614 
2615     if (wifi_bw == BTC_WIFI_BW_LEGACY) {
2616         /* for SCO quality at 11b/g mode */
2617         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2618     } else {
2619         /* for SCO quality & wifi performance balance at 11n mode */
2620         if (wifi_bw == BTC_WIFI_BW_HT40) {
2621             btc8821a2ant_coex_table_with_type(btcoexist,
2622                               NORMAL_EXEC, 8);
2623         } else {
2624             if (bt_link_info->sco_only)
2625                 btc8821a2ant_coex_table_with_type(
2626                     btcoexist, NORMAL_EXEC, 17);
2627             else
2628                 btc8821a2ant_coex_table_with_type(
2629                     btcoexist, NORMAL_EXEC, 12);
2630         }
2631     }
2632 
2633     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2634     /* for voice quality */
2635     btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2636 
2637     /* sw mechanism */
2638     if (wifi_bw == BTC_WIFI_BW_HT40) {
2639         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2640             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2641             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2642                            false, false);
2643             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2644                            true, 0x18);
2645         } else {
2646             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2647                            false, false);
2648             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2649                            true, 0x18);
2650         }
2651     } else {
2652         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2653             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2654             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2655                            false, false);
2656             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2657                            true, 0x18);
2658         } else {
2659             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2660                            false, false);
2661             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2662                            true, 0x18);
2663         }
2664     }
2665 }
2666 
2667 static void btc8821a2ant_action_hid(struct btc_coexist *btcoexist)
2668 {
2669     u8 wifi_rssi_state, bt_rssi_state;
2670     u32 wifi_bw;
2671 
2672     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2673     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2674         2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2675 
2676     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2677 
2678     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2679     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2680 
2681     if (BTC_RSSI_HIGH(bt_rssi_state))
2682         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2683     else
2684         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2685 
2686     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2687 
2688     if (wifi_bw == BTC_WIFI_BW_LEGACY) {
2689         /* for HID at 11b/g mode */
2690         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2691     } else {
2692         /* for HID quality & wifi performance balance at 11n mode */
2693         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2694     }
2695 
2696     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2697     btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 24);
2698 
2699     if (wifi_bw == BTC_WIFI_BW_HT40) {
2700         /* sw mechanism */
2701         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2702             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2703             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2704                            false, false);
2705             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2706                            false, 0x18);
2707         } else {
2708             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2709                            false, false);
2710             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2711                            false, 0x18);
2712         }
2713     } else {
2714         /* sw mechanism */
2715         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2716             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2717             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2718                            false, false);
2719             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2720                            false, 0x18);
2721         } else {
2722             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2723                            false, false);
2724             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2725                            false, 0x18);
2726         }
2727     }
2728 }
2729 
2730 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2731 static void btc8821a2ant_action_a2dp(struct btc_coexist *btcoexist)
2732 {
2733     u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2734     u8 ap_num = 0;
2735     u32 wifi_bw;
2736 
2737     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2738     wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2739                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2740     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2741         2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2742 
2743     if ((ap_num >= 10) && BTC_RSSI_HIGH(wifi_rssi_state1) &&
2744         BTC_RSSI_HIGH(bt_rssi_state)) {
2745         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2746                           0x0, 0x0);
2747 
2748         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2749                       0x0);
2750         btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2751                     0x8);
2752         btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2753         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2754 
2755         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2756 
2757         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2758                           0x0, 0x0);
2759         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2760 
2761         /* sw mechanism */
2762         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2763         if (wifi_bw == BTC_WIFI_BW_HT40) {
2764             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2765                            false, false);
2766             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2767                            true, 0x6);
2768         } else {
2769             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2770                            false, false);
2771             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2772                            true, 0x6);
2773         }
2774         return;
2775     }
2776 
2777     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2778     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2779 
2780     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2781 
2782     if (BTC_RSSI_HIGH(bt_rssi_state))
2783         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2784     else
2785         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2786 
2787     if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2788         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2789         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2790                           0x0, 0x0);
2791     } else {
2792         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2793         btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2794                           0x4);
2795     }
2796 
2797     /* preserve identical branches for further fine-tuning */
2798     if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2799         (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2800         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2801     } else {
2802         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2803     }
2804 
2805     /* sw mechanism */
2806     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2807     if (wifi_bw == BTC_WIFI_BW_HT40) {
2808         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2809             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2810             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2811                            false, false);
2812             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2813                            false, 0x18);
2814         } else {
2815             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2816                            false, false);
2817             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2818                            false, 0x18);
2819         }
2820     } else {
2821         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2822             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2823             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2824                            false, false);
2825             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2826                            false, 0x18);
2827         } else {
2828             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2829                            false, false);
2830             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2831                            false, 0x18);
2832         }
2833     }
2834 }
2835 
2836 static void btc8821a2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2837 {
2838     u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2839     u32 wifi_bw;
2840 
2841     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2842     wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2843                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2844     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2845         2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2846 
2847     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2848 
2849     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2850     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2851 
2852     if (BTC_RSSI_HIGH(bt_rssi_state))
2853         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2854     else
2855         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2856 
2857     if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2858         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2859         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2860                           0x0, 0x0);
2861     } else {
2862         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2863         btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2864                           0x4);
2865     }
2866 
2867     btc8821a2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2868 
2869     /* sw mechanism */
2870     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2871     if (wifi_bw == BTC_WIFI_BW_HT40) {
2872         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2873             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2874             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2875                            false, false);
2876             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2877                            false, 0x18);
2878         } else {
2879             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2880                            false, false);
2881             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2882                            false, 0x18);
2883         }
2884     } else {
2885         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2886             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2887             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2888                            false, false);
2889             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2890                            false, 0x18);
2891         } else {
2892             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2893                            false, false);
2894             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2895                            false, 0x18);
2896         }
2897     }
2898 }
2899 
2900 static void btc8821a2ant_action_pan_edr(struct btc_coexist *btcoexist)
2901 {
2902     u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2903     u32 wifi_bw;
2904 
2905     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2906     wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2907                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2908     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2909                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2910 
2911     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2912 
2913     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2914 
2915     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2916 
2917     if (BTC_RSSI_HIGH(bt_rssi_state))
2918         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2919     else
2920         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2921 
2922     if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2923         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 10);
2924         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2925                           0x0, 0x0);
2926     } else {
2927         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2928         btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2929                           0x4);
2930     }
2931 
2932     /* preserve identical branches for further fine-tuning */
2933     if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2934         (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2935         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 26);
2936     else
2937         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 26);
2938 
2939     /* sw mechanism */
2940     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2941     if (wifi_bw == BTC_WIFI_BW_HT40) {
2942         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2943             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2944             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2945                            false, false);
2946             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2947                            false, 0x18);
2948         } else {
2949             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2950                            false, false);
2951             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2952                            false, 0x18);
2953         }
2954     } else {
2955         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2956             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2957             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2958                            false, false);
2959             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2960                            false, 0x18);
2961         } else {
2962             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2963                            false, false);
2964             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2965                            false, 0x18);
2966         }
2967     }
2968 }
2969 
2970 /* PAN(HS) only */
2971 static void btc8821a2ant_action_pan_hs(struct btc_coexist *btcoexist)
2972 {
2973     u8 wifi_rssi_state, bt_rssi_state;
2974     u32 wifi_bw;
2975 
2976     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2977     btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2978                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2979     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2980                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2981 
2982     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2983 
2984     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2985     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2986 
2987     if (BTC_RSSI_HIGH(bt_rssi_state))
2988         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2989     else
2990         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2991 
2992     btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2993     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2994     btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2995 
2996     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2997     if (wifi_bw == BTC_WIFI_BW_HT40) {
2998         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2999             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3000             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3001                            false, false);
3002             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3003                            false, 0x18);
3004         } else {
3005             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3006                            false, false);
3007             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3008                            false, 0x18);
3009         }
3010     } else {
3011         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3012             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3013             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3014                            false, false);
3015             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3016                            false, 0x18);
3017         } else {
3018             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3019                            false, false);
3020             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3021                            false, 0x18);
3022         }
3023     }
3024 }
3025 
3026 /* PAN(EDR)+A2DP */
3027 static void btc8821a2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
3028 {
3029     u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3030     u32 wifi_bw;
3031 
3032     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3033     wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3034                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3035     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3036                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3037 
3038     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3039 
3040     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3041 
3042     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3043 
3044     if (BTC_RSSI_HIGH(bt_rssi_state))
3045         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3046     else
3047         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3048 
3049     if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state))
3050         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3051                           0x0, 0x0);
3052     else
3053         btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3054                           0x4);
3055 
3056     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3057 
3058     if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3059         (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3060         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
3061 
3062         if (wifi_bw == BTC_WIFI_BW_HT40)
3063             btc8821a2ant_tdma_duration_adjust(btcoexist, false,
3064                               true, 3);
3065         else
3066             btc8821a2ant_tdma_duration_adjust(btcoexist, false,
3067                               false, 3);
3068     } else {
3069         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3070         btc8821a2ant_tdma_duration_adjust(btcoexist, false, true, 3);
3071     }
3072 
3073     /* sw mechanism  */
3074     if (wifi_bw == BTC_WIFI_BW_HT40) {
3075         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3076             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3077             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3078                            false, false);
3079             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3080                            false, 0x18);
3081         } else {
3082             btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3083                            false, false);
3084             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3085                            false, 0x18);
3086         }
3087     } else {
3088         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3089             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3090             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3091                            false, false);
3092             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3093                            false, 0x18);
3094         } else {
3095             btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3096                            false, false);
3097             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3098                            false, 0x18);
3099         }
3100     }
3101 }
3102 
3103 static void btc8821a2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
3104 {
3105     u8 wifi_rssi_state, bt_rssi_state;
3106     u32 wifi_bw;
3107 
3108     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3109     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3110                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3111 
3112     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3113 
3114     if (BTC_RSSI_HIGH(bt_rssi_state))
3115         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
3116     else
3117         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
3118 
3119     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3120 
3121     /* preserve identical branches for further fine-tuning */
3122     if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3123         /* for HID at 11b/g mode */
3124         btc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3125                     0x5a5f5a5f, 0xffff, 0x3);
3126     } else {
3127         /* for HID quality & wifi performance balance at 11n mode */
3128         btc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3129                     0x5a5f5a5f, 0xffff, 0x3);
3130     }
3131 
3132     if (wifi_bw == BTC_WIFI_BW_HT40) {
3133         btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 3);
3134         /* fw mechanism */
3135         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3136             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3137             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3138                          true, 10);
3139         } else {
3140             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
3141         }
3142 
3143         /* sw mechanism */
3144         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3145             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3146             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3147                            false, false);
3148             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3149                            false, 0x18);
3150         } else {
3151             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3152                            false, false);
3153             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3154                            false, 0x18);
3155         }
3156     } else {
3157         btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3158         /* fw mechanism */
3159         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3160             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3161             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
3162         } else {
3163             btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
3164         }
3165 
3166         /* sw mechanism */
3167         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3168             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3169             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3170                            false, false);
3171             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3172                            false, 0x18);
3173         } else {
3174             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3175                            false, false);
3176             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3177                            false, 0x18);
3178         }
3179     }
3180 }
3181 
3182 /* HID+A2DP+PAN(EDR) */
3183 static void btc8821a2ant_act_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
3184 {
3185     u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3186     u32 wifi_bw;
3187 
3188     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3189     wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3190                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3191     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3192                 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3193 
3194     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3195 
3196     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3197     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3198 
3199     if (BTC_RSSI_HIGH(bt_rssi_state))
3200         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3201     else
3202         btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3203 
3204     if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3205         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3206         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3207                           0x0, 0x0);
3208     } else {
3209         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3210         btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3211                           0x4);
3212     }
3213 
3214     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3215 
3216     if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3217         (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3218         if (wifi_bw == BTC_WIFI_BW_HT40)
3219             btc8821a2ant_tdma_duration_adjust(btcoexist, true,
3220                               true, 3);
3221         else
3222             btc8821a2ant_tdma_duration_adjust(btcoexist, true,
3223                               false, 3);
3224     } else {
3225         btc8821a2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3226     }
3227 
3228     /* sw mechanism */
3229     if (wifi_bw == BTC_WIFI_BW_HT40) {
3230         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3231             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3232             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3233                            false, false);
3234             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3235                            false, 0x18);
3236         } else {
3237             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3238                            false, false);
3239             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3240                            false, 0x18);
3241         }
3242     } else {
3243         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3244             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3245             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3246                            false, false);
3247             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3248                            false, 0x18);
3249         } else {
3250             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3251                            false, false);
3252             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3253                            false, 0x18);
3254         }
3255     }
3256 }
3257 
3258 static void btc8821a2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3259 {
3260     u32 wifi_bw;
3261     u8 wifi_rssi_state, bt_rssi_state;
3262     u8 ap_num = 0;
3263 
3264     wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3265     btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3266                 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3267     bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3268                 3, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 37);
3269 
3270     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3271 
3272     btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3273     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3274 
3275     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3276     if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3277         if (BTC_RSSI_HIGH(bt_rssi_state))
3278             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3279         else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3280             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3281         else
3282             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3283     } else {
3284         /* only 802.11N mode we have to dec bt power to 4 degree */
3285         if (BTC_RSSI_HIGH(bt_rssi_state)) {
3286             btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3287                        &ap_num);
3288             if (ap_num < 10)
3289                 btc8821a2ant_dec_bt_pwr(btcoexist,
3290                             NORMAL_EXEC, 4);
3291             else
3292                 btc8821a2ant_dec_bt_pwr(btcoexist,
3293                             NORMAL_EXEC, 2);
3294         } else if (BTC_RSSI_MEDIUM(bt_rssi_state)) {
3295             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3296         } else {
3297             btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3298         }
3299     }
3300 
3301     if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3302         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3303         btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3304                           0x0, 0x0);
3305     } else {
3306         btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3307         btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3308                           0x4);
3309     }
3310 
3311     /* preserve identical branches for further fine-tuning */
3312     if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3313         (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3314         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
3315     } else {
3316         btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
3317     }
3318 
3319     /* sw mechanism */
3320     if (wifi_bw == BTC_WIFI_BW_HT40) {
3321         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3322             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3323             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3324                            false, false);
3325             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3326                            false, 0x18);
3327         } else {
3328             btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3329                            false, false);
3330             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3331                            false, 0x18);
3332         }
3333     } else {
3334         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3335             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3336             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3337                            false, false);
3338             btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3339                            false, 0x18);
3340         } else {
3341             btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3342                            false, false);
3343             btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3344                            false, 0x18);
3345         }
3346     }
3347 }
3348 
3349 static void btc8821a2ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
3350 {
3351     btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3352     btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3353 
3354     /* sw all off */
3355     btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
3356     btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
3357 
3358     /* hw all off */
3359     btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3360 
3361     btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3362     btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3363 }
3364 
3365 static void btc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3366 {
3367     struct rtl_priv *rtlpriv = btcoexist->adapter;
3368     struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3369     bool wifi_under_5g = false;
3370     u8 algorithm = 0;
3371     u32 num_of_wifi_link = 0;
3372     u32 wifi_link_status = 0;
3373     bool miracast_plus_bt = false;
3374     bool scan = false, link = false, roam = false;
3375 
3376     if (btcoexist->manual_control) {
3377         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3378             "[BTCoex], Manual control!!!\n");
3379         return;
3380     }
3381 
3382     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3383 
3384     if (wifi_under_5g) {
3385         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3386             "[BTCoex], RunCoexistMechanism(), run 5G coex setting!!<===\n");
3387         btc8821a2ant_coex_under_5g(btcoexist);
3388         return;
3389     }
3390 
3391     if (coex_sta->under_ips) {
3392         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3393             "[BTCoex], wifi is under IPS !!!\n");
3394         return;
3395     }
3396 
3397     algorithm = btc8821a2ant_action_algorithm(btcoexist);
3398     if (coex_sta->c2h_bt_inquiry_page &&
3399         (BT_8821A_2ANT_COEX_ALGO_PANHS != algorithm)) {
3400         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3401             "[BTCoex], BT is under inquiry/page scan !!\n");
3402         btc8821a2ant_action_bt_inquiry(btcoexist);
3403         return;
3404     }
3405 
3406     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3407     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3408     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3409 
3410     if (scan || link || roam) {
3411         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3412             "[BTCoex], WiFi is under Link Process !!\n");
3413         btc8821a2ant_action_wifi_link_process(btcoexist);
3414         return;
3415     }
3416 
3417     /* for P2P */
3418     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3419                &wifi_link_status);
3420     num_of_wifi_link = wifi_link_status >> 16;
3421 
3422     if ((num_of_wifi_link >= 2) ||
3423         (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3424         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3425             "############# [BTCoex],  Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3426             num_of_wifi_link, wifi_link_status);
3427 
3428         if (bt_link_info->bt_link_exist)
3429             miracast_plus_bt = true;
3430         else
3431             miracast_plus_bt = false;
3432 
3433         btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3434                    &miracast_plus_bt);
3435         btc8821a2ant_action_wifi_multi_port(btcoexist);
3436 
3437         return;
3438     }
3439 
3440     miracast_plus_bt = false;
3441     btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3442                &miracast_plus_bt);
3443 
3444     coex_dm->cur_algorithm = algorithm;
3445     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3446         "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
3447 
3448     if (btc8821a2ant_is_common_action(btcoexist)) {
3449         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3450             "[BTCoex], Action 2-Ant common\n");
3451         coex_dm->auto_tdma_adjust = true;
3452     } else {
3453         if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3454             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3455                 "[BTCoex], pre_algorithm = %d, cur_algorithm = %d\n",
3456                 coex_dm->pre_algorithm,
3457                 coex_dm->cur_algorithm);
3458             coex_dm->auto_tdma_adjust = false;
3459         }
3460         switch (coex_dm->cur_algorithm) {
3461         case BT_8821A_2ANT_COEX_ALGO_SCO:
3462             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3463                 "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3464             btc8821a2ant_action_sco(btcoexist);
3465             break;
3466         case BT_8821A_2ANT_COEX_ALGO_HID:
3467             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3468                 "[BTCoex], Action 2-Ant, algorithm = HID\n");
3469             btc8821a2ant_action_hid(btcoexist);
3470             break;
3471         case BT_8821A_2ANT_COEX_ALGO_A2DP:
3472             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3473                 "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3474             btc8821a2ant_action_a2dp(btcoexist);
3475             break;
3476         case BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS:
3477             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3478                 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3479             btc8821a2ant_action_a2dp_pan_hs(btcoexist);
3480             break;
3481         case BT_8821A_2ANT_COEX_ALGO_PANEDR:
3482             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3483                 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3484             btc8821a2ant_action_pan_edr(btcoexist);
3485             break;
3486         case BT_8821A_2ANT_COEX_ALGO_PANHS:
3487             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3488                 "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3489             btc8821a2ant_action_pan_hs(btcoexist);
3490             break;
3491         case BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP:
3492             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3493                 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3494             btc8821a2ant_action_pan_edr_a2dp(btcoexist);
3495             break;
3496         case BT_8821A_2ANT_COEX_ALGO_PANEDR_HID:
3497             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3498                 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3499             btc8821a2ant_action_pan_edr_hid(btcoexist);
3500             break;
3501         case BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3502             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3503                 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3504             btc8821a2ant_act_hid_a2dp_pan_edr(btcoexist);
3505             break;
3506         case BT_8821A_2ANT_COEX_ALGO_HID_A2DP:
3507             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3508                 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3509             btc8821a2ant_action_hid_a2dp(btcoexist);
3510             break;
3511         default:
3512             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3513                 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3514             btc8821a2ant_coex_all_off(btcoexist);
3515             break;
3516         }
3517         coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3518     }
3519 }
3520 
3521 static void btc8821a2ant_wifi_off_hw_cfg(struct btc_coexist *btcoexist)
3522 {
3523     u8 h2c_parameter[2] = {0};
3524     u32 fw_ver = 0;
3525 
3526     /* set wlan_act to low */
3527     btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3528 
3529     /* WiFi goto standby while GNT_BT 0-->1 */
3530     btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
3531     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3532     if (fw_ver >= 0x180000) {
3533         /* Use H2C to set GNT_BT to HIGH */
3534         h2c_parameter[0] = 1;
3535         btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
3536     } else {
3537         btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
3538     }
3539 }
3540 
3541 /**************************************************************
3542  * extern function start with ex_btc8821a2ant_
3543  **************************************************************/
3544 void ex_btc8821a2ant_init_hwconfig(struct btc_coexist *btcoexist)
3545 {
3546     struct rtl_priv *rtlpriv = btcoexist->adapter;
3547     u8 u1tmp = 0;
3548 
3549     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3550         "[BTCoex], 2Ant Init HW Config!!\n");
3551 
3552     /* backup rf 0x1e value */
3553     coex_dm->bt_rf0x1e_backup =
3554         btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3555 
3556     /* 0x790[5:0] = 0x5 */
3557     u1tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3558     u1tmp &= 0xc0;
3559     u1tmp |= 0x5;
3560     btcoexist->btc_write_1byte(btcoexist, 0x790, u1tmp);
3561 
3562     /* Antenna config */
3563     btc8821a2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN, true, false);
3564     coex_sta->dis_ver_info_cnt = 0;
3565 
3566     /* PTA parameter */
3567     btc8821a2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3568 
3569     /* Enable counter statistics */
3570     /* 0x76e[3] = 1, WLAN_Act control by PTA */
3571     btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3572     btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3573     btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3574 }
3575 
3576 void ex_btc8821a2ant_pre_load_firmware(struct btc_coexist *btcoexist)
3577 {
3578     struct btc_board_info *board_info = &btcoexist->board_info;
3579     u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
3580 
3581     /**
3582      * S0 or S1 setting and Local register setting(By the setting fw can get
3583      * ant number, S0/S1, ... info)
3584      *
3585      * Local setting bit define
3586      *  BIT0: "0" for no antenna inverse; "1" for antenna inverse
3587      *  BIT1: "0" for internal switch; "1" for external switch
3588      *  BIT2: "0" for one antenna; "1" for two antenna
3589      * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
3590      * BIT2=0
3591      */
3592     if (btcoexist->chip_interface == BTC_INTF_USB) {
3593         /* fixed at S0 for USB interface */
3594         u8tmp |= 0x1; /* antenna inverse */
3595         btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3596     } else {
3597         /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3598         if (board_info->single_ant_path == 0) {
3599         } else if (board_info->single_ant_path == 1) {
3600             /* set to S0 */
3601             u8tmp |= 0x1; /* antenna inverse */
3602         }
3603 
3604         if (btcoexist->chip_interface == BTC_INTF_PCI)
3605             btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
3606                                  u8tmp);
3607         else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3608             btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
3609                                  u8tmp);
3610     }
3611 }
3612 
3613 void ex_btc8821a2ant_init_coex_dm(struct btc_coexist *btcoexist)
3614 {
3615     struct rtl_priv *rtlpriv = btcoexist->adapter;
3616 
3617     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3618         "[BTCoex], Coex Mechanism Init!!\n");
3619 
3620     btc8821a2ant_init_coex_dm(btcoexist);
3621 }
3622 
3623 void ex_btc8821a2ant_display_coex_info(struct btc_coexist *btcoexist,
3624                        struct seq_file *m)
3625 {
3626     struct btc_board_info *board_info = &btcoexist->board_info;
3627     struct btc_stack_info *stack_info = &btcoexist->stack_info;
3628     u8 u1tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3629     u32 u4tmp[4];
3630     bool roam = false, scan = false, link = false, wifi_under_5g = false;
3631     bool bt_hs_on = false, wifi_busy = false;
3632     long wifi_rssi = 0, bt_hs_rssi = 0;
3633     u32 wifi_bw, wifi_traffic_dir;
3634     u8 wifi_dot_11_chnl, wifi_hs_chnl;
3635     u32 fw_ver = 0, bt_patch_ver = 0;
3636 
3637     seq_puts(m, "\n ============[BT Coexist info]============");
3638 
3639     seq_printf(m, "\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:",
3640            board_info->pg_ant_num, board_info->btdm_ant_num);
3641 
3642     if (btcoexist->manual_control) {
3643         seq_printf(m, "\n %-35s", "[Action Manual control]!!");
3644     }
3645 
3646     seq_printf(m, "\n %-35s = %s / %d", "BT stack/ hci ext ver",
3647            ((stack_info->profile_notified) ? "Yes" : "No"),
3648            stack_info->hci_version);
3649 
3650     btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3651     btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3652     seq_printf(m, "\n %-35s = %d_%d/ 0x%x/ 0x%x(%d)",
3653            "CoexVer/ FwVer/ PatchVer",
3654            glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
3655            fw_ver, bt_patch_ver, bt_patch_ver);
3656 
3657     btcoexist->btc_get(btcoexist,
3658         BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3659     btcoexist->btc_get(btcoexist,
3660         BTC_GET_U1_WIFI_DOT11_CHNL, &wifi_dot_11_chnl);
3661     btcoexist->btc_get(btcoexist,
3662         BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3663     seq_printf(m, "\n %-35s = %d / %d(%d)",
3664            "Dot11 channel / HsMode(HsChnl)",
3665            wifi_dot_11_chnl, bt_hs_on, wifi_hs_chnl);
3666 
3667     seq_printf(m, "\n %-35s = %3ph ",
3668            "H2C Wifi inform bt chnl Info",
3669            coex_dm->wifi_chnl_info);
3670 
3671     btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3672     btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3673     seq_printf(m, "\n %-35s = %ld/ %ld", "Wifi rssi/ HS rssi",
3674            wifi_rssi, bt_hs_rssi);
3675 
3676     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3677     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3678     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3679     seq_printf(m, "\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
3680            link, roam, scan);
3681 
3682     btcoexist->btc_get(btcoexist,
3683         BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3684     btcoexist->btc_get(btcoexist,
3685         BTC_GET_U4_WIFI_BW, &wifi_bw);
3686     btcoexist->btc_get(btcoexist,
3687         BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3688     btcoexist->btc_get(btcoexist,
3689         BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifi_traffic_dir);
3690     seq_printf(m, "\n %-35s = %s / %s/ %s ", "Wifi status",
3691            (wifi_under_5g ? "5G" : "2.4G"),
3692            ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3693             (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3694            ((!wifi_busy) ? "idle" :
3695             ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3696              "uplink" : "downlink")));
3697 
3698     if (stack_info->profile_notified) {
3699         seq_printf(m, "\n %-35s = %d / %d / %d / %d",
3700                "SCO/HID/PAN/A2DP",
3701                stack_info->sco_exist, stack_info->hid_exist,
3702                stack_info->pan_exist, stack_info->a2dp_exist);
3703 
3704         btcoexist->btc_disp_dbg_msg(btcoexist,
3705                         BTC_DBG_DISP_BT_LINK_INFO,
3706                         m);
3707     }
3708 
3709     bt_info_ext = coex_sta->bt_info_ext;
3710     seq_printf(m, "\n %-35s = %s", "BT Info A2DP rate",
3711            (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3712 
3713     for (i = 0; i < BT_INFO_SRC_8821A_2ANT_MAX; i++) {
3714         if (coex_sta->bt_info_c2h_cnt[i]) {
3715             seq_printf(m, "\n %-35s = %7ph(%d)",
3716                    glbt_info_src_8821a_2ant[i],
3717                    coex_sta->bt_info_c2h[i],
3718                    coex_sta->bt_info_c2h_cnt[i]);
3719         }
3720     }
3721 
3722     seq_printf(m, "\n %-35s = %s/%s",
3723            "PS state, IPS/LPS",
3724            ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3725            ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3726     btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
3727 
3728     /* Sw mechanism*/
3729     seq_printf(m, "\n %-35s",
3730            "============[Sw mechanism]============");
3731     seq_printf(m, "\n %-35s = %d/ %d/ %d(0x%x) ",
3732            "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3733            coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3734            coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3735 
3736     /* Fw mechanism*/
3737     seq_printf(m, "\n %-35s",
3738            "============[Fw mechanism]============");
3739 
3740     if (!btcoexist->manual_control) {
3741         ps_tdma_case = coex_dm->cur_ps_tdma;
3742         seq_printf(m, "\n %-35s = %5ph case-%d",
3743                "PS TDMA",
3744                coex_dm->ps_tdma_para, ps_tdma_case);
3745 
3746         seq_printf(m, "\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct",
3747                coex_dm->cur_dec_bt_pwr_lvl,
3748                coex_dm->cur_ignore_wlan_act);
3749     }
3750 
3751     /* Hw setting*/
3752     seq_printf(m, "\n %-35s", "============[Hw setting]============");
3753 
3754     seq_printf(m, "\n %-35s = 0x%x", "RF-A, 0x1e initVal",
3755            coex_dm->bt_rf0x1e_backup);
3756 
3757     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3758     u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3759     seq_printf(m, "\n %-35s = 0x%x/ 0x%x ",
3760            "0x778 (W_Act)/ 0x6cc (CoTab Sel)",
3761            u1tmp[0], u1tmp[1]);
3762 
3763     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
3764     u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xc5b);
3765     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3766            "0x8db(ADC)/0xc5b[29:25](DAC)",
3767            ((u1tmp[0] & 0x60) >> 5), ((u1tmp[1] & 0x3e) >> 1));
3768 
3769     u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
3770     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3771            "0xcb4[7:0](ctrl)/ 0xcb4[29:28](val)",
3772            u4tmp[0] & 0xff, ((u4tmp[0] & 0x30000000) >> 28));
3773 
3774     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3775     u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3776     u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x974);
3777     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3778            "0x40/ 0x4c[24:23]/ 0x974",
3779            u1tmp[0], ((u4tmp[0] & 0x01800000) >> 23), u4tmp[1]);
3780 
3781     u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3782     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3783     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3784            "0x550(bcn ctrl)/0x522",
3785            u4tmp[0], u1tmp[0]);
3786 
3787     u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3788     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa0a);
3789     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3790            "0xc50(DIG)/0xa0a(CCK-TH)",
3791            u4tmp[0], u1tmp[0]);
3792 
3793     u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
3794     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3795     u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3796     seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3797            "OFDM-FA/ CCK-FA",
3798            u4tmp[0], (u1tmp[0] << 8) + u1tmp[1]);
3799 
3800     u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3801     u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3802     u4tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3803     seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3804            "0x6c0/0x6c4/0x6c8",
3805            u4tmp[0], u4tmp[1], u4tmp[2]);
3806 
3807     seq_printf(m, "\n %-35s = %d/ %d",
3808            "0x770 (hi-pri Rx/Tx)",
3809            coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3810     seq_printf(m, "\n %-35s = %d/ %d",
3811            "0x774(low-pri Rx/Tx)",
3812            coex_sta->low_priority_rx, coex_sta->low_priority_tx);
3813 
3814     /* Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang*/
3815     u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x41b);
3816     seq_printf(m, "\n %-35s = 0x%x",
3817            "0x41b (mgntQ hang chk == 0xf)",
3818            u1tmp[0]);
3819 
3820     btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
3821 }
3822 
3823 void ex_btc8821a2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3824 {
3825     struct rtl_priv *rtlpriv = btcoexist->adapter;
3826 
3827     if (BTC_IPS_ENTER == type) {
3828         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3829             "[BTCoex], IPS ENTER notify\n");
3830         coex_sta->under_ips = true;
3831         btc8821a2ant_wifi_off_hw_cfg(btcoexist);
3832         btc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3833         btc8821a2ant_coex_all_off(btcoexist);
3834     } else if (BTC_IPS_LEAVE == type) {
3835         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3836             "[BTCoex], IPS LEAVE notify\n");
3837         coex_sta->under_ips = false;
3838         ex_btc8821a2ant_init_hwconfig(btcoexist);
3839         btc8821a2ant_init_coex_dm(btcoexist);
3840         btc8821a2ant_query_bt_info(btcoexist);
3841     }
3842 }
3843 
3844 void ex_btc8821a2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3845 {
3846     struct rtl_priv *rtlpriv = btcoexist->adapter;
3847 
3848     if (BTC_LPS_ENABLE == type) {
3849         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3850             "[BTCoex], LPS ENABLE notify\n");
3851         coex_sta->under_lps = true;
3852     } else if (BTC_LPS_DISABLE == type) {
3853         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3854             "[BTCoex], LPS DISABLE notify\n");
3855         coex_sta->under_lps = false;
3856     }
3857 }
3858 
3859 void ex_btc8821a2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3860 {
3861     struct rtl_priv *rtlpriv = btcoexist->adapter;
3862 
3863     if (BTC_SCAN_START == type) {
3864         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3865             "[BTCoex], SCAN START notify\n");
3866     } else if (BTC_SCAN_FINISH == type) {
3867         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3868             "[BTCoex], SCAN FINISH notify\n");
3869     }
3870 }
3871 
3872 void ex_btc8821a2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3873 {
3874     struct rtl_priv *rtlpriv = btcoexist->adapter;
3875 
3876     if (BTC_ASSOCIATE_START == type) {
3877         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3878             "[BTCoex], CONNECT START notify\n");
3879     } else if (BTC_ASSOCIATE_FINISH == type) {
3880         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3881             "[BTCoex], CONNECT FINISH notify\n");
3882     }
3883 }
3884 
3885 void ex_btc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
3886                      u8 type)
3887 {
3888     struct rtl_priv *rtlpriv = btcoexist->adapter;
3889     u8 h2c_parameter[3] = {0};
3890     u32 wifi_bw;
3891     u8 wifi_central_chnl;
3892     u8 ap_num = 0;
3893 
3894     if (BTC_MEDIA_CONNECT == type) {
3895         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3896             "[BTCoex], MEDIA connect notify\n");
3897     } else {
3898         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3899             "[BTCoex], MEDIA disconnect notify\n");
3900     }
3901 
3902     /* only 2.4G we need to inform bt the chnl mask */
3903     btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
3904                &wifi_central_chnl);
3905     if ((BTC_MEDIA_CONNECT == type) &&
3906         (wifi_central_chnl <= 14)) {
3907         h2c_parameter[0] = 0x1;
3908         h2c_parameter[1] = wifi_central_chnl;
3909         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3910         if (wifi_bw == BTC_WIFI_BW_HT40) {
3911             h2c_parameter[2] = 0x30;
3912         } else {
3913             h2c_parameter[2] = 0x20;
3914             if (ap_num < 10)
3915                 h2c_parameter[2] = 0x30;
3916             else
3917                 h2c_parameter[2] = 0x20;
3918         }
3919     }
3920 
3921     coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3922     coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3923     coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3924 
3925     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3926         "[BTCoex], FW write 0x66 = 0x%x\n",
3927         h2c_parameter[0] << 16 |
3928         h2c_parameter[1] << 8 |
3929         h2c_parameter[2]);
3930 
3931     btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3932 }
3933 
3934 void ex_btc8821a2ant_special_packet_notify(struct btc_coexist *btcoexist,
3935                        u8 type)
3936 {
3937     struct rtl_priv *rtlpriv = btcoexist->adapter;
3938 
3939     if (type == BTC_PACKET_DHCP) {
3940         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3941             "[BTCoex], DHCP Packet notify\n");
3942     }
3943 }
3944 
3945 void ex_btc8821a2ant_bt_info_notify(struct btc_coexist *btcoexist,
3946                     u8 *tmp_buf, u8 length)
3947 {
3948     struct rtl_priv *rtlpriv = btcoexist->adapter;
3949     u8 bt_info = 0;
3950     u8 i, rsp_source = 0;
3951     bool bt_busy = false, limited_dig = false;
3952     bool wifi_connected = false, wifi_under_5g = false;
3953 
3954     coex_sta->c2h_bt_info_req_sent = false;
3955     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3956     btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3957                &wifi_connected);
3958 
3959     rsp_source = tmp_buf[0] & 0xf;
3960     if (rsp_source >= BT_INFO_SRC_8821A_2ANT_MAX)
3961         rsp_source = BT_INFO_SRC_8821A_2ANT_WIFI_FW;
3962     coex_sta->bt_info_c2h_cnt[rsp_source]++;
3963 
3964     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3965         "[BTCoex], Bt info[%d], length = %d, hex data = [",
3966         rsp_source, length);
3967     for (i = 0; i < length; i++) {
3968         coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3969         if (i == 1)
3970             bt_info = tmp_buf[i];
3971         if (i == length - 1) {
3972             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3973                 "0x%02x]\n", tmp_buf[i]);
3974         } else {
3975             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3976                 "0x%02x, ", tmp_buf[i]);
3977         }
3978     }
3979 
3980     if (btcoexist->manual_control) {
3981         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3982             "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
3983         return;
3984     }
3985 
3986     if (BT_INFO_SRC_8821A_2ANT_WIFI_FW != rsp_source) {
3987         /* [3:0] */
3988         coex_sta->bt_retry_cnt =
3989             coex_sta->bt_info_c2h[rsp_source][2]&0xf;
3990 
3991         coex_sta->bt_rssi =
3992             coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
3993 
3994         coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
3995 
3996         coex_sta->bt_tx_rx_mask =
3997             (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
3998         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
3999                    &coex_sta->bt_tx_rx_mask);
4000         if (coex_sta->bt_tx_rx_mask) {
4001             /* BT into is responded by BT FW and BT RF REG 0x3C !=
4002              * 0x01 => Need to switch BT TRx Mask
4003              */
4004             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4005                 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n");
4006             btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
4007                           0x3c, 0x01);
4008         }
4009 
4010         /* Here we need to resend some wifi info to BT
4011          * because bt is reset and loss of the info
4012          */
4013         if ((coex_sta->bt_info_ext & BIT1)) {
4014             btcoexist->btc_get(btcoexist,
4015                 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
4016             if (wifi_connected) {
4017                 ex_btc8821a2ant_media_status_notify(btcoexist,
4018                     BTC_MEDIA_CONNECT);
4019             } else {
4020                 ex_btc8821a2ant_media_status_notify(btcoexist,
4021                     BTC_MEDIA_DISCONNECT);
4022             }
4023 
4024         }
4025 
4026         if (!btcoexist->manual_control && !wifi_under_5g) {
4027             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4028                 "[BTCoex], BT ext info = 0x%x!!\n",
4029                 coex_sta->bt_info_ext);
4030             if ((coex_sta->bt_info_ext & BIT(3))) {
4031                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4032                     "[BTCoex], BT ext info bit3=1, wifi_connected=%d\n",
4033                     wifi_connected);
4034                 if (wifi_connected) {
4035                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
4036                         DBG_LOUD,
4037                         "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4038                     btc8821a2ant_ignore_wlan_act(btcoexist,
4039                                      FORCE_EXEC,
4040                                      false);
4041                 }
4042             } else {
4043                 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4044                     "[BTCoex], BT ext info bit3=0, wifi_connected=%d\n",
4045                     wifi_connected);
4046                 /* BT already NOT ignore Wlan active, do nothing
4047                  * here.
4048                  */
4049                 if (!wifi_connected) {
4050                     rtl_dbg(rtlpriv, COMP_BT_COEXIST,
4051                         DBG_LOUD,
4052                         "[BTCoex], BT ext info bit3 check, set BT to ignore Wlan active!!\n");
4053                     btc8821a2ant_ignore_wlan_act(
4054                         btcoexist, FORCE_EXEC, true);
4055                 }
4056             }
4057         }
4058     }
4059 
4060     /* check BIT2 first ==> check if bt is under inquiry or page scan*/
4061     if (bt_info & BT_INFO_8821A_2ANT_B_INQ_PAGE) {
4062         coex_sta->c2h_bt_inquiry_page = true;
4063     } else {
4064         coex_sta->c2h_bt_inquiry_page = false;
4065     }
4066     /* set link exist status */
4067     if (!(bt_info & BT_INFO_8821A_2ANT_B_CONNECTION)) {
4068         coex_sta->bt_link_exist = false;
4069         coex_sta->pan_exist = false;
4070         coex_sta->a2dp_exist = false;
4071         coex_sta->hid_exist = false;
4072         coex_sta->sco_exist = false;
4073     } else { /* connection exists */
4074         coex_sta->bt_link_exist = true;
4075         if (bt_info & BT_INFO_8821A_2ANT_B_FTP)
4076             coex_sta->pan_exist = true;
4077         else
4078             coex_sta->pan_exist = false;
4079         if (bt_info & BT_INFO_8821A_2ANT_B_A2DP)
4080             coex_sta->a2dp_exist = true;
4081         else
4082             coex_sta->a2dp_exist = false;
4083         if (bt_info & BT_INFO_8821A_2ANT_B_HID)
4084             coex_sta->hid_exist = true;
4085         else
4086             coex_sta->hid_exist = false;
4087         if (bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO)
4088             coex_sta->sco_exist = true;
4089         else
4090             coex_sta->sco_exist = false;
4091 
4092         if ((!coex_sta->hid_exist) &&
4093             (!coex_sta->c2h_bt_inquiry_page) &&
4094             (!coex_sta->sco_exist)) {
4095             if (coex_sta->high_priority_tx +
4096                     coex_sta->high_priority_rx >= 160)
4097                 coex_sta->hid_exist = true;
4098         }
4099     }
4100 
4101     btc8821a2ant_update_bt_link_info(btcoexist);
4102 
4103     if (!(bt_info & BT_INFO_8821A_2ANT_B_CONNECTION)) {
4104         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_IDLE;
4105         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4106             "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4107     } else if (bt_info == BT_INFO_8821A_2ANT_B_CONNECTION) {
4108         /* connection exists but no busy */
4109         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_CON_IDLE;
4110         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4111             "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4112     } else if ((bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO) ||
4113            (bt_info & BT_INFO_8821A_2ANT_B_SCO_BUSY)) {
4114         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_SCO_BUSY;
4115         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4116             "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4117     } else if (bt_info & BT_INFO_8821A_2ANT_B_ACL_BUSY) {
4118         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_ACL_BUSY;
4119         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4120             "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4121     } else {
4122         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_MAX;
4123         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4124             "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4125     }
4126 
4127     if ((coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_ACL_BUSY) ||
4128         (coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_SCO_BUSY) ||
4129         (coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_ACL_SCO_BUSY)) {
4130         bt_busy = true;
4131         limited_dig = true;
4132     } else {
4133         bt_busy = false;
4134         limited_dig = false;
4135     }
4136 
4137     btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4138 
4139     coex_dm->limited_dig = limited_dig;
4140     btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4141 
4142     btc8821a2ant_run_coexist_mechanism(btcoexist);
4143 }
4144 
4145 void ex_btc8821a2ant_halt_notify(struct btc_coexist *btcoexist)
4146 {
4147     struct rtl_priv *rtlpriv = btcoexist->adapter;
4148 
4149     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4150         "[BTCoex], Halt notify\n");
4151 
4152     btc8821a2ant_wifi_off_hw_cfg(btcoexist);
4153     btc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4154     ex_btc8821a2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4155 }
4156 
4157 void ex_btc8821a2ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
4158 {
4159     struct rtl_priv *rtlpriv = btcoexist->adapter;
4160 
4161     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
4162 
4163     if (pnp_state == BTC_WIFI_PNP_SLEEP) {
4164         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4165             "[BTCoex], Pnp notify to SLEEP\n");
4166     } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
4167         rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4168             "[BTCoex], Pnp notify to WAKE UP\n");
4169         ex_btc8821a2ant_init_hwconfig(btcoexist);
4170         btc8821a2ant_init_coex_dm(btcoexist);
4171         btc8821a2ant_query_bt_info(btcoexist);
4172     }
4173 }
4174 
4175 void ex_btc8821a2ant_periodical(struct btc_coexist *btcoexist)
4176 {
4177     struct rtl_priv *rtlpriv = btcoexist->adapter;
4178 
4179     rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4180         "[BTCoex], ==========================Periodical===========================\n");
4181 
4182     if (coex_sta->dis_ver_info_cnt <= 5) {
4183         coex_sta->dis_ver_info_cnt += 1;
4184         if (coex_sta->dis_ver_info_cnt == 3) {
4185             /* Antenna config to set 0x765 = 0x0 (GNT_BT control by
4186              * PTA) after initial
4187              */
4188             rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4189                 "[BTCoex], Set GNT_BT control by PTA\n");
4190             btc8821a2ant_set_ant_path(btcoexist,
4191                     BTC_ANT_WIFI_AT_MAIN, false, false);
4192         }
4193     }
4194 
4195     if (btcoexist->auto_report_2ant) {
4196         btc8821a2ant_query_bt_info(btcoexist);
4197     } else {
4198         btc8821a2ant_monitor_bt_ctr(btcoexist);
4199         btc8821a2ant_monitor_wifi_ctr(btcoexist);
4200 
4201         if (btc8821a2ant_is_wifi_status_changed(btcoexist) ||
4202             coex_dm->auto_tdma_adjust)
4203             btc8821a2ant_run_coexist_mechanism(btcoexist);
4204     }
4205 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!