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