1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
4 * Copyright(c) 2016 Realtek Corporation.
7 * wlanfae <wlanfae@realtek.com>
8 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
11 * Larry Finger <Larry.Finger@lwfinger.net>
13 *****************************************************************************/
14 /* ************************************************************
17 * This file is for RTL8822B Co-exist mechanism
20 * 2012/11/15 Cosa first check in.
22 * *************************************************************/
24 /* ************************************************************
26 * *************************************************************/
28 #include "halbt_precomp.h"
30 /* ************************************************************
31 * Global variables, these are static variables
32 * *************************************************************/
33 static struct coex_dm_8822b_1ant glcoex_dm_8822b_1ant;
34 static struct coex_dm_8822b_1ant *coex_dm = &glcoex_dm_8822b_1ant;
35 static struct coex_sta_8822b_1ant glcoex_sta_8822b_1ant;
36 static struct coex_sta_8822b_1ant *coex_sta = &glcoex_sta_8822b_1ant;
37 static struct psdscan_sta_8822b_1ant gl_psd_scan_8822b_1ant;
38 static struct psdscan_sta_8822b_1ant *psd_scan = &gl_psd_scan_8822b_1ant;
39 static struct rfe_type_8822b_1ant gl_rfe_type_8822b_1ant;
40 static struct rfe_type_8822b_1ant *rfe_type = &gl_rfe_type_8822b_1ant;
42 static const char *const glbt_info_src_8822b_1ant[] = {
43 "BT Info[wifi fw]", "BT Info[bt rsp]", "BT Info[bt auto report]",
46 static u32 glcoex_ver_date_8822b_1ant = 20170327;
47 static u32 glcoex_ver_8822b_1ant = 0x44;
48 static u32 glcoex_ver_btdesired_8822b_1ant = 0x42;
50 /* ************************************************************
51 * local function proto type if needed
52 * ************************************************************
53 * ************************************************************
54 * local function start with halbtc8822b1ant_
55 * *************************************************************/
57 static u8 halbtc8822b1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
58 u8 index, u8 level_num,
59 u8 rssi_thresh, u8 rssi_thresh1)
61 struct rtl_priv *rtlpriv = btcoexist->adapter;
63 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
65 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
68 if ((coex_sta->pre_wifi_rssi_state[index] ==
69 BTC_RSSI_STATE_LOW) ||
70 (coex_sta->pre_wifi_rssi_state[index] ==
71 BTC_RSSI_STATE_STAY_LOW)) {
73 (rssi_thresh + BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
74 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
76 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
78 if (wifi_rssi < rssi_thresh)
79 wifi_rssi_state = BTC_RSSI_STATE_LOW;
81 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
83 } else if (level_num == 3) {
84 if (rssi_thresh > rssi_thresh1) {
85 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
86 "[BTCoex], wifi RSSI thresh error!!\n");
87 return coex_sta->pre_wifi_rssi_state[index];
90 if ((coex_sta->pre_wifi_rssi_state[index] ==
91 BTC_RSSI_STATE_LOW) ||
92 (coex_sta->pre_wifi_rssi_state[index] ==
93 BTC_RSSI_STATE_STAY_LOW)) {
95 (rssi_thresh + BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
96 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
98 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
99 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
100 BTC_RSSI_STATE_MEDIUM) ||
101 (coex_sta->pre_wifi_rssi_state[index] ==
102 BTC_RSSI_STATE_STAY_MEDIUM)) {
103 if (wifi_rssi >= (rssi_thresh1 +
104 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
105 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
106 else if (wifi_rssi < rssi_thresh)
107 wifi_rssi_state = BTC_RSSI_STATE_LOW;
109 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
111 if (wifi_rssi < rssi_thresh1)
112 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
114 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
118 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
120 return wifi_rssi_state;
123 static void halbtc8822b1ant_update_ra_mask(struct btc_coexist *btcoexist,
124 bool force_exec, u32 dis_rate_mask)
126 coex_dm->cur_ra_mask = dis_rate_mask;
128 if (force_exec || (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask))
129 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
130 &coex_dm->cur_ra_mask);
131 coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
135 halbtc8822b1ant_auto_rate_fallback_retry(struct btc_coexist *btcoexist,
136 bool force_exec, u8 type)
138 bool wifi_under_b_mode = false;
140 coex_dm->cur_arfr_type = type;
142 if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
143 switch (coex_dm->cur_arfr_type) {
144 case 0: /* normal mode */
145 btcoexist->btc_write_4byte(btcoexist, 0x430,
146 coex_dm->backup_arfr_cnt1);
147 btcoexist->btc_write_4byte(btcoexist, 0x434,
148 coex_dm->backup_arfr_cnt2);
151 btcoexist->btc_get(btcoexist,
152 BTC_GET_BL_WIFI_UNDER_B_MODE,
154 if (wifi_under_b_mode) {
155 btcoexist->btc_write_4byte(btcoexist, 0x430,
157 btcoexist->btc_write_4byte(btcoexist, 0x434,
160 btcoexist->btc_write_4byte(btcoexist, 0x430,
162 btcoexist->btc_write_4byte(btcoexist, 0x434,
171 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
174 static void halbtc8822b1ant_retry_limit(struct btc_coexist *btcoexist,
175 bool force_exec, u8 type)
177 coex_dm->cur_retry_limit_type = type;
180 (coex_dm->pre_retry_limit_type != coex_dm->cur_retry_limit_type)) {
181 switch (coex_dm->cur_retry_limit_type) {
182 case 0: /* normal mode */
183 btcoexist->btc_write_2byte(btcoexist, 0x42a,
184 coex_dm->backup_retry_limit);
186 case 1: /* retry limit=8 */
187 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
194 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
197 static void halbtc8822b1ant_ampdu_max_time(struct btc_coexist *btcoexist,
198 bool force_exec, u8 type)
200 coex_dm->cur_ampdu_time_type = type;
203 (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
204 switch (coex_dm->cur_ampdu_time_type) {
205 case 0: /* normal mode */
206 btcoexist->btc_write_1byte(
208 coex_dm->backup_ampdu_max_time);
210 case 1: /* AMPDU timw = 0x38 * 32us */
211 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
218 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
221 static void halbtc8822b1ant_limited_tx(struct btc_coexist *btcoexist,
222 bool force_exec, u8 ra_mask_type,
223 u8 arfr_type, u8 retry_limit_type,
226 switch (ra_mask_type) {
227 case 0: /* normal mode */
228 halbtc8822b1ant_update_ra_mask(btcoexist, force_exec, 0x0);
230 case 1: /* disable cck 1/2 */
231 halbtc8822b1ant_update_ra_mask(btcoexist, force_exec,
234 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
235 halbtc8822b1ant_update_ra_mask(btcoexist, force_exec,
242 halbtc8822b1ant_auto_rate_fallback_retry(btcoexist, force_exec,
244 halbtc8822b1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
245 halbtc8822b1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
249 * rx agg size setting :
250 * 1: true / don't care / don't care
251 * max: false / false / don't care
252 * 7: false / true / 7
255 static void halbtc8822b1ant_limited_rx(struct btc_coexist *btcoexist,
256 bool force_exec, bool rej_ap_agg_pkt,
257 bool bt_ctrl_agg_buf_size,
260 bool reject_rx_agg = rej_ap_agg_pkt;
261 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
262 u8 rx_agg_size = agg_buf_size;
264 /* ============================================ */
265 /* Rx Aggregation related setting */
266 /* ============================================ */
267 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
269 /* decide BT control aggregation buf size or not */
270 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
271 &bt_ctrl_rx_agg_size);
272 /* aggregation buf size, only work when BT control Rx aggregation size*/
273 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
274 /* real update aggregation setting */
275 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
278 static void halbtc8822b1ant_query_bt_info(struct btc_coexist *btcoexist)
280 struct rtl_priv *rtlpriv = btcoexist->adapter;
281 u8 h2c_parameter[1] = {0};
283 if (coex_sta->bt_disabled) {
285 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
286 "[BTCoex], No query BT info because BT is disabled!\n");
290 h2c_parameter[0] |= BIT(0); /* trigger */
292 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
294 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
295 "[BTCoex], WL query BT info!!\n");
298 static void halbtc8822b1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
300 struct rtl_priv *rtlpriv = btcoexist->adapter;
301 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
302 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
303 static u8 num_of_bt_counter_chk, cnt_slave, cnt_autoslot_hang;
304 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
309 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
310 reg_hp_tx = u32tmp & MASKLWORD;
311 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
313 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
314 reg_lp_tx = u32tmp & MASKLWORD;
315 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
317 coex_sta->high_priority_tx = reg_hp_tx;
318 coex_sta->high_priority_rx = reg_hp_rx;
319 coex_sta->low_priority_tx = reg_lp_tx;
320 coex_sta->low_priority_rx = reg_lp_rx;
322 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
323 "[BTCoex], Hi-Pri Rx/Tx: %d/%d, Lo-Pri Rx/Tx: %d/%d\n",
324 reg_hp_rx, reg_hp_tx, reg_lp_rx, reg_lp_tx);
327 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
329 if ((coex_sta->low_priority_tx > 1150) &&
330 (!coex_sta->c2h_bt_inquiry_page))
331 coex_sta->pop_event_cnt++;
333 if ((coex_sta->low_priority_rx >= 1150) &&
334 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
335 (!coex_sta->under_ips) && (!coex_sta->c2h_bt_inquiry_page) &&
336 (coex_sta->bt_link_exist)) {
337 if (cnt_slave >= 3) {
338 bt_link_info->slave_role = true;
344 if (cnt_slave == 0) {
345 bt_link_info->slave_role = false;
352 if (coex_sta->is_tdma_btautoslot) {
353 if ((coex_sta->low_priority_tx >= 1300) &&
354 (coex_sta->low_priority_rx <= 150)) {
355 if (cnt_autoslot_hang >= 2) {
356 coex_sta->is_tdma_btautoslot_hang = true;
357 cnt_autoslot_hang = 2;
362 if (cnt_autoslot_hang == 0) {
363 coex_sta->is_tdma_btautoslot_hang = false;
364 cnt_autoslot_hang = 0;
371 if (bt_link_info->hid_only) {
372 if (coex_sta->low_priority_rx > 50)
373 coex_sta->is_hid_low_pri_tx_overhead = true;
375 coex_sta->is_hid_low_pri_tx_overhead = false;
378 if ((coex_sta->high_priority_tx == 0) &&
379 (coex_sta->high_priority_rx == 0) &&
380 (coex_sta->low_priority_tx == 0) &&
381 (coex_sta->low_priority_rx == 0)) {
382 num_of_bt_counter_chk++;
384 if (num_of_bt_counter_chk >= 3) {
385 halbtc8822b1ant_query_bt_info(btcoexist);
386 num_of_bt_counter_chk = 0;
391 static void halbtc8822b1ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
394 bool wifi_busy = false, wifi_under_b_mode = false, wifi_scan = false;
395 static u8 cck_lock_counter, wl_noisy_count0, wl_noisy_count1 = 3,
397 u32 total_cnt, cck_cnt;
399 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
400 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
401 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
404 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
406 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_phy_counter(
407 btcoexist, "PHYDM_INFO_CRC32_OK_CCK");
408 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_phy_counter(
409 btcoexist, "PHYDM_INFO_CRC32_OK_LEGACY");
410 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_phy_counter(
411 btcoexist, "PHYDM_INFO_CRC32_OK_HT");
412 coex_sta->crc_ok_11n_vht = btcoexist->btc_phydm_query_phy_counter(
413 btcoexist, "PHYDM_INFO_CRC32_OK_VHT");
415 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_phy_counter(
416 btcoexist, "PHYDM_INFO_CRC32_ERROR_CCK");
417 coex_sta->crc_err_11g = btcoexist->btc_phydm_query_phy_counter(
418 btcoexist, "PHYDM_INFO_CRC32_ERROR_LEGACY");
419 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_phy_counter(
420 btcoexist, "PHYDM_INFO_CRC32_ERROR_HT");
421 coex_sta->crc_err_11n_vht = btcoexist->btc_phydm_query_phy_counter(
422 btcoexist, "PHYDM_INFO_CRC32_ERROR_VHT");
424 cck_cnt = coex_sta->crc_ok_cck + coex_sta->crc_err_cck;
427 if (wl_noisy_count2 < 3)
430 if (wl_noisy_count2 == 3) {
435 } else if (cck_cnt < 50) {
436 if (wl_noisy_count0 < 3)
439 if (wl_noisy_count0 == 3) {
445 if (wl_noisy_count1 < 3)
448 if (wl_noisy_count1 == 3) {
454 if (wl_noisy_count2 == 3)
455 coex_sta->wl_noisy_level = 2;
456 else if (wl_noisy_count1 == 3)
457 coex_sta->wl_noisy_level = 1;
459 coex_sta->wl_noisy_level = 0;
461 if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
462 total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
463 coex_sta->crc_ok_11n + coex_sta->crc_ok_11n_vht;
465 if ((coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) ||
466 (coex_dm->bt_status ==
467 BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
468 (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_SCO_BUSY)) {
469 if (coex_sta->crc_ok_cck >
470 (total_cnt - coex_sta->crc_ok_cck)) {
471 if (cck_lock_counter < 3)
474 if (cck_lock_counter > 0)
479 if (cck_lock_counter > 0)
483 if (cck_lock_counter > 0)
487 if (!coex_sta->pre_ccklock) {
488 if (cck_lock_counter >= 3)
489 coex_sta->cck_lock = true;
491 coex_sta->cck_lock = false;
493 if (cck_lock_counter == 0)
494 coex_sta->cck_lock = false;
496 coex_sta->cck_lock = true;
499 if (coex_sta->cck_lock)
500 coex_sta->cck_ever_lock = true;
502 coex_sta->pre_ccklock = coex_sta->cck_lock;
506 halbtc8822b1ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
508 struct rtl_priv *rtlpriv = btcoexist->adapter;
509 static bool pre_wifi_busy, pre_under_4way, pre_bt_hs_on,
510 pre_rf4ce_enabled, pre_bt_off, pre_bt_slave,
511 pre_hid_low_pri_tx_overhead, pre_wifi_under_lps,
513 static u8 pre_hid_busy_num, pre_wl_noisy_level;
514 bool wifi_busy = false, under_4way = false, bt_hs_on = false,
515 rf4ce_enabled = false;
516 bool wifi_connected = false;
517 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
519 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
521 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
522 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
523 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
526 if (coex_sta->bt_disabled != pre_bt_off) {
527 pre_bt_off = coex_sta->bt_disabled;
529 if (coex_sta->bt_disabled)
530 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
531 "[BTCoex], BT is disabled !!\n");
533 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
534 "[BTCoex], BT is enabled !!\n");
536 coex_sta->bt_coex_supported_feature = 0;
537 coex_sta->bt_coex_supported_version = 0;
540 btcoexist->btc_get(btcoexist, BTC_GET_BL_RF4CE_CONNECTED,
543 if (rf4ce_enabled != pre_rf4ce_enabled) {
544 pre_rf4ce_enabled = rf4ce_enabled;
547 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
548 "[BTCoex], rf4ce is enabled !!\n");
550 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
551 "[BTCoex], rf4ce is disabled !!\n");
556 if (wifi_connected) {
557 if (wifi_busy != pre_wifi_busy) {
558 pre_wifi_busy = wifi_busy;
561 if (under_4way != pre_under_4way) {
562 pre_under_4way = under_4way;
565 if (bt_hs_on != pre_bt_hs_on) {
566 pre_bt_hs_on = bt_hs_on;
569 if (coex_sta->wl_noisy_level != pre_wl_noisy_level) {
570 pre_wl_noisy_level = coex_sta->wl_noisy_level;
573 if (coex_sta->under_lps != pre_wifi_under_lps) {
574 pre_wifi_under_lps = coex_sta->under_lps;
575 if (coex_sta->under_lps)
580 if (!coex_sta->bt_disabled) {
581 if (coex_sta->hid_busy_num != pre_hid_busy_num) {
582 pre_hid_busy_num = coex_sta->hid_busy_num;
586 if (bt_link_info->slave_role != pre_bt_slave) {
587 pre_bt_slave = bt_link_info->slave_role;
591 if (pre_hid_low_pri_tx_overhead !=
592 coex_sta->is_hid_low_pri_tx_overhead) {
593 pre_hid_low_pri_tx_overhead =
594 coex_sta->is_hid_low_pri_tx_overhead;
598 if (pre_bt_setup_link != coex_sta->is_setup_link) {
599 pre_bt_setup_link = coex_sta->is_setup_link;
607 static void halbtc8822b1ant_update_bt_link_info(struct btc_coexist *btcoexist)
609 struct rtl_priv *rtlpriv = btcoexist->adapter;
610 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
611 bool bt_hs_on = false;
612 bool bt_busy = false;
614 coex_sta->num_of_profile = 0;
616 /* set link exist status */
617 if (!(coex_sta->bt_info & BT_INFO_8822B_1ANT_B_CONNECTION)) {
618 coex_sta->bt_link_exist = false;
619 coex_sta->pan_exist = false;
620 coex_sta->a2dp_exist = false;
621 coex_sta->hid_exist = false;
622 coex_sta->sco_exist = false;
623 } else { /* connection exists */
624 coex_sta->bt_link_exist = true;
625 if (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_FTP) {
626 coex_sta->pan_exist = true;
627 coex_sta->num_of_profile++;
629 coex_sta->pan_exist = false;
632 if (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_A2DP) {
633 coex_sta->a2dp_exist = true;
634 coex_sta->num_of_profile++;
636 coex_sta->a2dp_exist = false;
639 if (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_HID) {
640 coex_sta->hid_exist = true;
641 coex_sta->num_of_profile++;
643 coex_sta->hid_exist = false;
646 if (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_SCO_ESCO) {
647 coex_sta->sco_exist = true;
648 coex_sta->num_of_profile++;
650 coex_sta->sco_exist = false;
654 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
656 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
657 bt_link_info->sco_exist = coex_sta->sco_exist;
658 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
659 bt_link_info->pan_exist = coex_sta->pan_exist;
660 bt_link_info->hid_exist = coex_sta->hid_exist;
661 bt_link_info->acl_busy = coex_sta->acl_busy;
663 /* work around for HS mode. */
665 bt_link_info->pan_exist = true;
666 bt_link_info->bt_link_exist = true;
669 /* check if Sco only */
670 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
671 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
672 bt_link_info->sco_only = true;
674 bt_link_info->sco_only = false;
676 /* check if A2dp only */
677 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
678 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
679 bt_link_info->a2dp_only = true;
681 bt_link_info->a2dp_only = false;
683 /* check if Pan only */
684 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
685 bt_link_info->pan_exist && !bt_link_info->hid_exist)
686 bt_link_info->pan_only = true;
688 bt_link_info->pan_only = false;
690 /* check if Hid only */
691 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
692 !bt_link_info->pan_exist && bt_link_info->hid_exist)
693 bt_link_info->hid_only = true;
695 bt_link_info->hid_only = false;
697 if (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_INQ_PAGE) {
698 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_INQ_PAGE;
699 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
700 "[BTCoex], BtInfoNotify(), BT Inq/page!!!\n");
701 } else if (!(coex_sta->bt_info & BT_INFO_8822B_1ANT_B_CONNECTION)) {
702 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
704 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
705 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
706 } else if (coex_sta->bt_info == BT_INFO_8822B_1ANT_B_CONNECTION) {
707 /* connection exists but no busy */
708 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_CONNECTED_IDLE;
709 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
710 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
711 } else if (((coex_sta->bt_info & BT_INFO_8822B_1ANT_B_SCO_ESCO) ||
712 (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_SCO_BUSY)) &&
713 (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_ACL_BUSY)) {
714 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY;
715 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
716 "[BTCoex], BtInfoNotify(), BT ACL SCO busy!!!\n");
717 } else if ((coex_sta->bt_info & BT_INFO_8822B_1ANT_B_SCO_ESCO) ||
718 (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_SCO_BUSY)) {
719 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_SCO_BUSY;
720 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
721 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
722 } else if (coex_sta->bt_info & BT_INFO_8822B_1ANT_B_ACL_BUSY) {
723 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_ACL_BUSY;
724 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
725 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
727 coex_dm->bt_status = BT_8822B_1ANT_BT_STATUS_MAX;
728 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
729 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
732 if ((coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) ||
733 (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_SCO_BUSY) ||
734 (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY))
739 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
742 static void halbtc8822b1ant_update_wifi_ch_info(struct btc_coexist *btcoexist,
745 u8 h2c_parameter[3] = {0};
747 u8 wifi_central_chnl;
749 /* only 2.4G we need to inform bt the chnl mask */
750 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
752 if ((type == BTC_MEDIA_CONNECT) && (wifi_central_chnl <= 14)) {
753 /* enable BT AFH skip WL channel for 8822b
754 * because BT Rx LO interference
756 h2c_parameter[0] = 0x1;
757 h2c_parameter[1] = wifi_central_chnl;
759 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
761 if (wifi_bw == BTC_WIFI_BW_HT40)
762 h2c_parameter[2] = 0x30;
764 h2c_parameter[2] = 0x20;
767 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
768 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
769 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
771 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
774 static u8 halbtc8822b1ant_action_algorithm(struct btc_coexist *btcoexist)
776 struct rtl_priv *rtlpriv = btcoexist->adapter;
777 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
778 bool bt_hs_on = false;
779 u8 algorithm = BT_8822B_1ANT_COEX_ALGO_UNDEFINED;
780 u8 num_of_diff_profile = 0;
782 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
784 if (!bt_link_info->bt_link_exist) {
785 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
786 "[BTCoex], No BT link exists!!!\n");
790 if (bt_link_info->sco_exist)
791 num_of_diff_profile++;
792 if (bt_link_info->hid_exist)
793 num_of_diff_profile++;
794 if (bt_link_info->pan_exist)
795 num_of_diff_profile++;
796 if (bt_link_info->a2dp_exist)
797 num_of_diff_profile++;
799 if (num_of_diff_profile == 1) {
800 if (bt_link_info->sco_exist) {
801 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
802 "[BTCoex], BT Profile = SCO only\n");
803 algorithm = BT_8822B_1ANT_COEX_ALGO_SCO;
805 if (bt_link_info->hid_exist) {
806 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
807 "[BTCoex], BT Profile = HID only\n");
808 algorithm = BT_8822B_1ANT_COEX_ALGO_HID;
809 } else if (bt_link_info->a2dp_exist) {
810 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
811 "[BTCoex], BT Profile = A2DP only\n");
812 algorithm = BT_8822B_1ANT_COEX_ALGO_A2DP;
813 } else if (bt_link_info->pan_exist) {
816 rtlpriv, COMP_BT_COEXIST,
818 "[BTCoex], BT Profile = PAN(HS) only\n");
820 BT_8822B_1ANT_COEX_ALGO_PANHS;
823 rtlpriv, COMP_BT_COEXIST,
825 "[BTCoex], BT Profile = PAN(EDR) only\n");
827 BT_8822B_1ANT_COEX_ALGO_PANEDR;
831 } else if (num_of_diff_profile == 2) {
832 if (bt_link_info->sco_exist) {
833 if (bt_link_info->hid_exist) {
834 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
835 "[BTCoex], BT Profile = SCO + HID\n");
836 algorithm = BT_8822B_1ANT_COEX_ALGO_HID;
837 } else if (bt_link_info->a2dp_exist) {
839 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
840 "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
841 algorithm = BT_8822B_1ANT_COEX_ALGO_SCO;
842 } else if (bt_link_info->pan_exist) {
845 rtlpriv, COMP_BT_COEXIST,
847 "[BTCoex], BT Profile = SCO + PAN(HS)\n");
848 algorithm = BT_8822B_1ANT_COEX_ALGO_SCO;
851 rtlpriv, COMP_BT_COEXIST,
853 "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
855 BT_8822B_1ANT_COEX_ALGO_PANEDR_HID;
859 if (bt_link_info->hid_exist &&
860 bt_link_info->a2dp_exist) {
861 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
862 "[BTCoex], BT Profile = HID + A2DP\n");
863 algorithm = BT_8822B_1ANT_COEX_ALGO_HID_A2DP;
864 } else if (bt_link_info->hid_exist &&
865 bt_link_info->pan_exist) {
868 rtlpriv, COMP_BT_COEXIST,
870 "[BTCoex], BT Profile = HID + PAN(HS)\n");
872 BT_8822B_1ANT_COEX_ALGO_HID_A2DP;
875 rtlpriv, COMP_BT_COEXIST,
877 "[BTCoex], BT Profile = HID + PAN(EDR)\n");
879 BT_8822B_1ANT_COEX_ALGO_PANEDR_HID;
881 } else if (bt_link_info->pan_exist &&
882 bt_link_info->a2dp_exist) {
885 rtlpriv, COMP_BT_COEXIST,
887 "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
889 BT_8822B_1ANT_COEX_ALGO_A2DP_PANHS;
892 rtlpriv, COMP_BT_COEXIST,
894 "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
896 BT_8822B_1ANT_COEX_ALGO_PANEDR_A2DP;
900 } else if (num_of_diff_profile == 3) {
901 if (bt_link_info->sco_exist) {
902 if (bt_link_info->hid_exist &&
903 bt_link_info->a2dp_exist) {
905 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
906 "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
907 algorithm = BT_8822B_1ANT_COEX_ALGO_HID;
908 } else if (bt_link_info->hid_exist &&
909 bt_link_info->pan_exist) {
912 rtlpriv, COMP_BT_COEXIST,
914 "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
916 BT_8822B_1ANT_COEX_ALGO_HID_A2DP;
919 rtlpriv, COMP_BT_COEXIST,
921 "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
923 BT_8822B_1ANT_COEX_ALGO_PANEDR_HID;
925 } else if (bt_link_info->pan_exist &&
926 bt_link_info->a2dp_exist) {
929 rtlpriv, COMP_BT_COEXIST,
931 "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
932 algorithm = BT_8822B_1ANT_COEX_ALGO_SCO;
935 rtlpriv, COMP_BT_COEXIST,
937 "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
939 BT_8822B_1ANT_COEX_ALGO_PANEDR_HID;
943 if (bt_link_info->hid_exist &&
944 bt_link_info->pan_exist &&
945 bt_link_info->a2dp_exist) {
948 rtlpriv, COMP_BT_COEXIST,
950 "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
952 BT_8822B_1ANT_COEX_ALGO_HID_A2DP;
955 rtlpriv, COMP_BT_COEXIST,
957 "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
959 BT_8822B_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
963 } else if (num_of_diff_profile >= 3) {
964 if (bt_link_info->sco_exist) {
965 if (bt_link_info->hid_exist &&
966 bt_link_info->pan_exist &&
967 bt_link_info->a2dp_exist) {
970 rtlpriv, COMP_BT_COEXIST,
972 "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
976 rtlpriv, COMP_BT_COEXIST,
978 "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
980 BT_8822B_1ANT_COEX_ALGO_PANEDR_HID;
989 static void halbtc8822b1ant_low_penalty_ra(struct btc_coexist *btcoexist,
990 bool force_exec, bool low_penalty_ra)
992 coex_dm->cur_low_penalty_ra = low_penalty_ra;
995 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
1000 btcoexist->btc_phydm_modify_ra_pcr_threshold(btcoexist, 0, 25);
1002 btcoexist->btc_phydm_modify_ra_pcr_threshold(btcoexist, 0, 0);
1004 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
1007 static void halbtc8822b1ant_write_score_board(struct btc_coexist *btcoexist,
1008 u16 bitpos, bool state)
1010 static u16 originalval = 0x8002;
1013 originalval = originalval | bitpos;
1015 originalval = originalval & (~bitpos);
1017 btcoexist->btc_write_2byte(btcoexist, 0xaa, originalval);
1020 static void halbtc8822b1ant_read_score_board(struct btc_coexist *btcoexist,
1021 u16 *score_board_val)
1024 (btcoexist->btc_read_2byte(btcoexist, 0xaa)) & 0x7fff;
1027 static void halbtc8822b1ant_post_state_to_bt(struct btc_coexist *btcoexist,
1028 u16 type, bool state)
1030 halbtc8822b1ant_write_score_board(btcoexist, (u16)type, state);
1034 halbtc8822b1ant_monitor_bt_enable_disable(struct btc_coexist *btcoexist)
1036 struct rtl_priv *rtlpriv = btcoexist->adapter;
1037 static u32 bt_disable_cnt;
1038 bool bt_active = true, bt_disabled = false, wifi_under_5g = false;
1041 /* This function check if bt is disabled */
1043 /* Read BT on/off status from scoreboard[1],
1044 * enable this only if BT patch support this feature
1046 halbtc8822b1ant_read_score_board(btcoexist, &u16tmp);
1048 bt_active = u16tmp & BIT(1);
1052 bt_disabled = false;
1053 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1057 if (bt_disable_cnt >= 2) {
1062 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1066 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
1068 if ((wifi_under_5g) || (bt_disabled))
1069 halbtc8822b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, false);
1071 halbtc8822b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, true);
1073 if (coex_sta->bt_disabled != bt_disabled) {
1074 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1075 "[BTCoex], BT is from %s to %s!!\n",
1076 (coex_sta->bt_disabled ? "disabled" : "enabled"),
1077 (bt_disabled ? "disabled" : "enabled"));
1078 coex_sta->bt_disabled = bt_disabled;
1082 static void halbtc8822b1ant_enable_gnt_to_gpio(struct btc_coexist *btcoexist,
1085 static u8 bit_val[5] = {0, 0, 0, 0, 0};
1088 if (!btcoexist->dbg_mode_1ant)
1091 if (state == isenable)
1097 /* enable GNT_WL, GNT_BT to GPIO for debug */
1098 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x1);
1100 /* store original value */
1102 (btcoexist->btc_read_1byte(btcoexist, 0x66) & BIT(4)) >>
1104 bit_val[1] = (btcoexist->btc_read_1byte(btcoexist, 0x67) &
1105 BIT(0)); /*0x66[8] */
1107 (btcoexist->btc_read_1byte(btcoexist, 0x42) & BIT(3)) >>
1110 (btcoexist->btc_read_1byte(btcoexist, 0x65) & BIT(7)) >>
1113 (btcoexist->btc_read_1byte(btcoexist, 0x72) & BIT(2)) >>
1116 /* switch GPIO Mux */
1117 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x66, BIT(4),
1118 0x0); /*0x66[4] = 0 */
1119 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, BIT(0),
1120 0x0); /*0x66[8] = 0 */
1121 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x42, BIT(3),
1122 0x0); /*0x40[19] = 0 */
1123 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x65, BIT(7),
1124 0x0); /*0x64[15] = 0 */
1125 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x72, BIT(2),
1126 0x0); /*0x70[18] = 0 */
1129 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x0);
1131 /* Restore original value */
1132 /* switch GPIO Mux */
1133 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x66, BIT(4),
1134 bit_val[0]); /*0x66[4] = 0 */
1135 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, BIT(0),
1136 bit_val[1]); /*0x66[8] = 0 */
1137 btcoexist->btc_write_1byte_bitmask(
1138 btcoexist, 0x42, BIT(3), bit_val[2]); /*0x40[19] = 0 */
1139 btcoexist->btc_write_1byte_bitmask(
1140 btcoexist, 0x65, BIT(7), bit_val[3]); /*0x64[15] = 0 */
1141 btcoexist->btc_write_1byte_bitmask(
1142 btcoexist, 0x72, BIT(2), bit_val[4]); /*0x70[18] = 0 */
1147 halbtc8822b1ant_ltecoex_indirect_read_reg(struct btc_coexist *btcoexist,
1150 u32 delay_count = 0;
1152 /* wait for ready bit before access 0x1700 */
1154 if ((btcoexist->btc_read_1byte(btcoexist, 0x1703) & BIT(5)) ==
1158 if (delay_count >= 10) {
1167 btcoexist->btc_write_4byte(btcoexist, 0x1700, 0x800F0000 | reg_addr);
1169 return btcoexist->btc_read_4byte(btcoexist, 0x1708); /* get read data */
1173 halbtc8822b1ant_ltecoex_indirect_write_reg(struct btc_coexist *btcoexist,
1174 u16 reg_addr, u32 bit_mask,
1177 u32 val, i = 0, bitpos = 0, delay_count = 0;
1179 if (bit_mask == 0x0)
1182 if (bit_mask == 0xffffffff) {
1183 /* wait for ready bit before access 0x1700/0x1704 */
1185 if ((btcoexist->btc_read_1byte(btcoexist, 0x1703) &
1189 if (delay_count >= 10) {
1198 btcoexist->btc_write_4byte(btcoexist, 0x1704,
1199 reg_value); /* put write data */
1201 btcoexist->btc_write_4byte(btcoexist, 0x1700,
1202 0xc00F0000 | reg_addr);
1204 for (i = 0; i <= 31; i++) {
1205 if (((bit_mask >> i) & 0x1) == 0x1) {
1211 /* read back register value before write */
1212 val = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
1214 val = (val & (~bit_mask)) | (reg_value << bitpos);
1216 /* wait for ready bit before access 0x1700/0x1704 */
1218 if ((btcoexist->btc_read_1byte(btcoexist, 0x1703) &
1222 if (delay_count >= 10) {
1231 btcoexist->btc_write_4byte(btcoexist, 0x1704,
1232 val); /* put write data */
1234 btcoexist->btc_write_4byte(btcoexist, 0x1700,
1235 0xc00F0000 | reg_addr);
1239 static void halbtc8822b1ant_ltecoex_enable(struct btc_coexist *btcoexist,
1244 val = (enable) ? 1 : 0;
1246 halbtc8822b1ant_ltecoex_indirect_write_reg(btcoexist, 0x38, 0x80, val);
1250 halbtc8822b1ant_ltecoex_pathcontrol_owner(struct btc_coexist *btcoexist,
1255 val = (wifi_control) ? 1 : 0;
1257 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x4, val);
1260 static void halbtc8822b1ant_ltecoex_set_gnt_bt(struct btc_coexist *btcoexist,
1262 bool sw_control, u8 state)
1264 u32 val = 0, bit_mask;
1266 state = state & 0x1;
1267 /*LTE indirect 0x38=0xccxx (sw : gnt_wl=1,sw gnt_bt=1)
1268 *0x38=0xddxx (sw : gnt_bt=1 , sw gnt_wl=0)
1269 *0x38=0x55xx(hw pta :gnt_wl /gnt_bt )
1271 val = (sw_control) ? ((state << 1) | 0x1) : 0;
1273 switch (control_block) {
1274 case BT_8822B_1ANT_GNT_BLOCK_RFC_BB:
1277 halbtc8822b1ant_ltecoex_indirect_write_reg(
1278 btcoexist, 0x38, bit_mask, val); /* 0x38[15:14] */
1280 halbtc8822b1ant_ltecoex_indirect_write_reg(
1281 btcoexist, 0x38, bit_mask, val); /* 0x38[11:10] */
1283 case BT_8822B_1ANT_GNT_BLOCK_RFC:
1285 halbtc8822b1ant_ltecoex_indirect_write_reg(
1286 btcoexist, 0x38, bit_mask, val); /* 0x38[15:14] */
1288 case BT_8822B_1ANT_GNT_BLOCK_BB:
1290 halbtc8822b1ant_ltecoex_indirect_write_reg(
1291 btcoexist, 0x38, bit_mask, val); /* 0x38[11:10] */
1296 static void halbtc8822b1ant_ltecoex_set_gnt_wl(struct btc_coexist *btcoexist,
1298 bool sw_control, u8 state)
1300 u32 val = 0, bit_mask;
1301 /*LTE indirect 0x38=0xccxx (sw : gnt_wl=1,sw gnt_bt=1)
1302 *0x38=0xddxx (sw : gnt_bt=1 , sw gnt_wl=0)
1303 *0x38=0x55xx(hw pta :gnt_wl /gnt_bt )
1306 state = state & 0x1;
1307 val = (sw_control) ? ((state << 1) | 0x1) : 0;
1309 switch (control_block) {
1310 case BT_8822B_1ANT_GNT_BLOCK_RFC_BB:
1313 halbtc8822b1ant_ltecoex_indirect_write_reg(
1314 btcoexist, 0x38, bit_mask, val); /* 0x38[13:12] */
1316 halbtc8822b1ant_ltecoex_indirect_write_reg(
1317 btcoexist, 0x38, bit_mask, val); /* 0x38[9:8] */
1319 case BT_8822B_1ANT_GNT_BLOCK_RFC:
1321 halbtc8822b1ant_ltecoex_indirect_write_reg(
1322 btcoexist, 0x38, bit_mask, val); /* 0x38[13:12] */
1324 case BT_8822B_1ANT_GNT_BLOCK_BB:
1326 halbtc8822b1ant_ltecoex_indirect_write_reg(
1327 btcoexist, 0x38, bit_mask, val); /* 0x38[9:8] */
1333 halbtc8822b1ant_ltecoex_set_coex_table(struct btc_coexist *btcoexist,
1334 u8 table_type, u16 table_content)
1336 u16 reg_addr = 0x0000;
1338 switch (table_type) {
1339 case BT_8822B_1ANT_CTT_WL_VS_LTE:
1342 case BT_8822B_1ANT_CTT_BT_VS_LTE:
1347 if (reg_addr != 0x0000)
1348 halbtc8822b1ant_ltecoex_indirect_write_reg(
1349 btcoexist, reg_addr, 0xffff,
1350 table_content); /* 0xa0[15:0] or 0xa4[15:0] */
1353 static void halbtc8822b1ant_set_wltoggle_coex_table(
1354 struct btc_coexist *btcoexist, bool force_exec, u8 interval,
1355 u8 val0x6c4_b0, u8 val0x6c4_b1, u8 val0x6c4_b2, u8 val0x6c4_b3)
1357 static u8 pre_h2c_parameter[6] = {0};
1358 u8 cur_h2c_parameter[6] = {0};
1359 u8 i, match_cnt = 0;
1361 cur_h2c_parameter[0] = 0x7; /* op_code, 0x7= wlan toggle slot*/
1363 cur_h2c_parameter[1] = interval;
1364 cur_h2c_parameter[2] = val0x6c4_b0;
1365 cur_h2c_parameter[3] = val0x6c4_b1;
1366 cur_h2c_parameter[4] = val0x6c4_b2;
1367 cur_h2c_parameter[5] = val0x6c4_b3;
1370 for (i = 1; i <= 5; i++) {
1371 if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
1381 for (i = 1; i <= 5; i++)
1382 pre_h2c_parameter[i] = cur_h2c_parameter[i];
1384 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, cur_h2c_parameter);
1387 static void halbtc8822b1ant_set_coex_table(struct btc_coexist *btcoexist,
1388 u32 val0x6c0, u32 val0x6c4,
1389 u32 val0x6c8, u8 val0x6cc)
1391 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
1393 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
1395 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
1397 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
1400 static void halbtc8822b1ant_coex_table(struct btc_coexist *btcoexist,
1401 bool force_exec, u32 val0x6c0,
1402 u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
1404 coex_dm->cur_val0x6c0 = val0x6c0;
1405 coex_dm->cur_val0x6c4 = val0x6c4;
1406 coex_dm->cur_val0x6c8 = val0x6c8;
1407 coex_dm->cur_val0x6cc = val0x6cc;
1410 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1411 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1412 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1413 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1416 halbtc8822b1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1419 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1420 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1421 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1422 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1425 static void halbtc8822b1ant_coex_table_with_type(struct btc_coexist *btcoexist,
1426 bool force_exec, u8 type)
1431 coex_sta->coex_table_type = type;
1433 if (coex_sta->concurrent_rx_mode_on) {
1434 break_table = 0xf0ffffff; /* set WL hi-pri can break BT */
1435 select_table = 0x3; /* set Tx response = Hi-Pri
1436 * (ex: Transmitting ACK,BA,CTS)
1439 break_table = 0xffffff;
1445 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1446 0x55555555, break_table,
1450 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1451 0x5a5a5a5a, break_table,
1455 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaa5a5a5a,
1456 0xaa5a5a5a, break_table,
1460 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1461 0xaa5a5a5a, break_table,
1465 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaa555555,
1466 0xaa5a5a5a, break_table,
1470 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
1471 0x5a5a5a5a, break_table,
1475 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1476 0xaaaaaaaa, break_table,
1480 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
1481 0xaaaaaaaa, break_table,
1485 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xffffffff,
1486 0xffffffff, break_table,
1490 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x5a5a5555,
1491 0xaaaa5a5a, break_table,
1495 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaaaa5aaa,
1496 0xaaaa5aaa, break_table,
1500 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaaaaa5aa,
1501 0xaaaaaaaa, break_table,
1505 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaaaaa5aa,
1506 0xaaaaa5aa, break_table,
1510 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1511 0xaaaa5a5a, break_table,
1515 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x5a5a555a,
1516 0xaaaa5a5a, break_table,
1520 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1521 0xaaaa55aa, break_table,
1525 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x5a5a555a,
1526 0x5a5a555a, break_table,
1530 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xaaaa55aa,
1531 0xaaaa55aa, break_table,
1535 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1536 0x5aaa5a5a, break_table,
1540 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0xa5555555,
1541 0xaaaa5aaa, break_table,
1545 halbtc8822b1ant_coex_table(btcoexist, force_exec, 0x55555555,
1546 0xaaaa5aaa, break_table,
1555 halbtc8822b1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
1558 u8 h2c_parameter[1] = {0};
1561 h2c_parameter[0] |= BIT(0); /* function enable */
1563 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1566 static void halbtc8822b1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1567 bool force_exec, bool enable)
1569 coex_dm->cur_ignore_wlan_act = enable;
1572 if (coex_dm->pre_ignore_wlan_act ==
1573 coex_dm->cur_ignore_wlan_act) {
1574 coex_dm->pre_ignore_wlan_act =
1575 coex_dm->cur_ignore_wlan_act;
1580 halbtc8822b1ant_set_fw_ignore_wlan_act(btcoexist, enable);
1582 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1585 static void halbtc8822b1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
1586 u8 lps_val, u8 rpwm_val)
1591 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1592 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1595 static void halbtc8822b1ant_lps_rpwm(struct btc_coexist *btcoexist,
1596 bool force_exec, u8 lps_val, u8 rpwm_val)
1598 coex_dm->cur_lps = lps_val;
1599 coex_dm->cur_rpwm = rpwm_val;
1602 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1603 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1606 halbtc8822b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1608 coex_dm->pre_lps = coex_dm->cur_lps;
1609 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1612 static void halbtc8822b1ant_ps_tdma_check_for_power_save_state(
1613 struct btc_coexist *btcoexist, bool new_ps_state)
1616 u8 h2c_parameter[5] = {0x8, 0, 0, 0, 0};
1618 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1620 if (lps_mode) { /* already under LPS state */
1622 /* keep state under LPS, do nothing. */
1624 /* will leave LPS state, turn off psTdma first */
1626 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1629 } else { /* NO PS state */
1631 /* will enter LPS state, turn off psTdma first */
1633 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1636 /* keep state under NO PS state, do nothing. */
1641 static bool halbtc8822b1ant_power_save_state(struct btc_coexist *btcoexist,
1642 u8 ps_type, u8 lps_val,
1645 bool low_pwr_disable = false, result = true;
1648 case BTC_PS_WIFI_NATIVE:
1649 /* recover to original 32k low power setting */
1650 coex_sta->force_lps_ctrl = false;
1651 low_pwr_disable = false;
1652 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1654 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1658 coex_sta->force_lps_ctrl = true;
1659 halbtc8822b1ant_ps_tdma_check_for_power_save_state(btcoexist,
1661 halbtc8822b1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1663 /* when coex force to enter LPS, do not enter 32k low power. */
1664 low_pwr_disable = true;
1665 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1667 /* power save must executed before psTdma. */
1668 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1671 case BTC_PS_LPS_OFF:
1673 coex_sta->force_lps_ctrl = true;
1674 halbtc8822b1ant_ps_tdma_check_for_power_save_state(btcoexist,
1676 result = btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1687 static void halbtc8822b1ant_set_fw_pstdma(struct btc_coexist *btcoexist,
1688 u8 byte1, u8 byte2, u8 byte3,
1691 struct rtl_priv *rtlpriv = btcoexist->adapter;
1692 u8 h2c_parameter[5] = {0};
1693 u8 real_byte1 = byte1, real_byte5 = byte5;
1694 bool ap_enable = false, result = false;
1695 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1698 coex_sta->is_tdma_btautoslot = true;
1700 coex_sta->is_tdma_btautoslot = false;
1702 /* release bt-auto slot for auto-slot hang is detected!! */
1703 if (coex_sta->is_tdma_btautoslot)
1704 if ((coex_sta->is_tdma_btautoslot_hang) ||
1705 (bt_link_info->slave_role))
1706 byte5 = byte5 & 0xfb;
1708 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1711 if ((ap_enable) && (byte1 & BIT(4) && !(byte1 & BIT(5)))) {
1712 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1713 "[BTCoex], %s == FW for 1Ant AP mode\n", __func__);
1715 real_byte1 &= ~BIT(4);
1716 real_byte1 |= BIT(5);
1718 real_byte5 |= BIT(5);
1719 real_byte5 &= ~BIT(6);
1721 halbtc8822b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1724 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1725 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1726 "[BTCoex], %s == Force LPS (byte1 = 0x%x)\n",
1728 if (!halbtc8822b1ant_power_save_state(btcoexist, BTC_PS_LPS_OFF,
1732 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1733 "[BTCoex], %s == native power save (byte1 = 0x%x)\n",
1735 halbtc8822b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1739 coex_sta->is_set_ps_state_fail = result;
1741 if (!coex_sta->is_set_ps_state_fail) {
1742 h2c_parameter[0] = real_byte1;
1743 h2c_parameter[1] = byte2;
1744 h2c_parameter[2] = byte3;
1745 h2c_parameter[3] = byte4;
1746 h2c_parameter[4] = real_byte5;
1748 coex_dm->ps_tdma_para[0] = real_byte1;
1749 coex_dm->ps_tdma_para[1] = byte2;
1750 coex_dm->ps_tdma_para[2] = byte3;
1751 coex_dm->ps_tdma_para[3] = byte4;
1752 coex_dm->ps_tdma_para[4] = real_byte5;
1754 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1757 coex_sta->cnt_set_ps_state_fail++;
1758 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1759 "[BTCoex], %s == Force Leave LPS Fail (cnt = %d)\n",
1760 __func__, coex_sta->cnt_set_ps_state_fail);
1764 static void halbtc8822b1ant_ps_tdma(struct btc_coexist *btcoexist,
1765 bool force_exec, bool turn_on, u8 type)
1767 struct rtl_priv *rtlpriv = btcoexist->adapter;
1768 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1769 bool wifi_busy = false;
1770 static u8 ps_tdma_byte4_modify, pre_ps_tdma_byte4_modify;
1771 static bool pre_wifi_busy;
1773 coex_dm->cur_ps_tdma_on = turn_on;
1774 coex_dm->cur_ps_tdma = type;
1776 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1778 if (wifi_busy != pre_wifi_busy) {
1780 pre_wifi_busy = wifi_busy;
1783 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1784 if (bt_link_info->slave_role)
1785 ps_tdma_byte4_modify = 0x1;
1787 ps_tdma_byte4_modify = 0x0;
1789 if (pre_ps_tdma_byte4_modify != ps_tdma_byte4_modify) {
1791 pre_ps_tdma_byte4_modify = ps_tdma_byte4_modify;
1795 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1796 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma)) {
1798 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1799 "[BTCoex], Skip TDMA because no change TDMA(%s, %d)\n",
1800 (coex_dm->cur_ps_tdma_on ? "on" : "off"),
1801 coex_dm->cur_ps_tdma);
1806 if (coex_dm->cur_ps_tdma_on) {
1807 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1808 "[BTCoex], ********** TDMA(on, %d) **********\n",
1809 coex_dm->cur_ps_tdma);
1811 btcoexist->btc_write_1byte_bitmask(
1812 btcoexist, 0x550, 0x8, 0x1); /* enable TBTT nterrupt */
1814 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1815 "[BTCoex], ********** TDMA(off, %d) **********\n",
1816 coex_dm->cur_ps_tdma);
1820 /* enable TBTT nterrupt */
1821 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8, 0x1);
1825 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x35,
1829 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x3a,
1833 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x30,
1837 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x21,
1841 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x15,
1845 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x20,
1849 halbtc8822b1ant_set_fw_pstdma(
1850 btcoexist, 0x51, 0x10, 0x03, 0x10,
1851 0x54 | ps_tdma_byte4_modify);
1854 halbtc8822b1ant_set_fw_pstdma(
1855 btcoexist, 0x51, 0x10, 0x03, 0x10,
1856 0x14 | ps_tdma_byte4_modify);
1859 halbtc8822b1ant_set_fw_pstdma(
1860 btcoexist, 0x61, 0x25, 0x03, 0x11,
1861 0x10 | ps_tdma_byte4_modify);
1864 halbtc8822b1ant_set_fw_pstdma(
1865 btcoexist, 0x51, 0x30, 0x03, 0x10,
1866 0x50 | ps_tdma_byte4_modify);
1869 halbtc8822b1ant_set_fw_pstdma(
1870 btcoexist, 0x51, 0x10, 0x07, 0x10,
1871 0x54 | ps_tdma_byte4_modify);
1874 halbtc8822b1ant_set_fw_pstdma(
1875 btcoexist, 0x51, 0x15, 0x03, 0x10,
1876 0x50 | ps_tdma_byte4_modify);
1879 halbtc8822b1ant_set_fw_pstdma(
1880 btcoexist, 0x51, 0x20, 0x03, 0x10,
1881 0x10 | ps_tdma_byte4_modify);
1884 halbtc8822b1ant_set_fw_pstdma(
1885 btcoexist, 0x61, 0x10, 0x03, 0x11,
1886 0x14 | ps_tdma_byte4_modify);
1889 halbtc8822b1ant_set_fw_pstdma(
1890 btcoexist, 0x51, 0x10, 0x03, 0x10,
1891 0x50 | ps_tdma_byte4_modify);
1895 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x30,
1899 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x25,
1903 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x10,
1907 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x35,
1911 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x35,
1915 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x45,
1919 halbtc8822b1ant_set_fw_pstdma(
1920 btcoexist, 0x51, 0x1e, 0x3, 0x10,
1921 0x14 | ps_tdma_byte4_modify);
1924 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x45,
1928 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x25,
1932 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x29,
1936 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x1a,
1940 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x32,
1944 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x29,
1948 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x55, 0x10,
1952 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x51, 0x4a,
1956 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x61, 0x35,
1963 default: /* Software control, Antenna at BT side */
1964 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x0, 0x0, 0x0,
1967 case 8: /* PTA Control */
1968 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x8, 0x0, 0x0,
1971 case 9: /* Software control, Antenna at WiFi side */
1972 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x0, 0x0, 0x0,
1975 case 10: /* under 5G , 0x778=1*/
1976 halbtc8822b1ant_set_fw_pstdma(btcoexist, 0x0, 0x0, 0x0,
1983 if (!coex_sta->is_set_ps_state_fail) {
1984 /* update pre state */
1985 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1986 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1990 static void halbtc8822b1ant_sw_mechanism(struct btc_coexist *btcoexist,
1991 bool low_penalty_ra)
1993 halbtc8822b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1996 /* rf4 type by efuse, and for ant at main aux inverse use,
1997 * because is 2x2, and control types are the same, does not need
2000 static void halbtc8822b1ant_set_rfe_type(struct btc_coexist *btcoexist)
2002 struct btc_board_info *board_info = &btcoexist->board_info;
2004 /* Ext switch buffer mux */
2005 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
2006 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x1991, 0x3, 0x0);
2007 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbe, 0x8, 0x0);
2009 /* the following setup should be got from Efuse in the future */
2010 rfe_type->rfe_module_type = board_info->rfe_type;
2012 rfe_type->ext_ant_switch_ctrl_polarity = 0;
2014 switch (rfe_type->rfe_module_type) {
2017 rfe_type->ext_ant_switch_exist = true;
2018 rfe_type->ext_ant_switch_type =
2019 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2022 rfe_type->ext_ant_switch_exist = true;
2023 rfe_type->ext_ant_switch_type =
2024 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2027 rfe_type->ext_ant_switch_exist = true;
2028 rfe_type->ext_ant_switch_type =
2029 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2032 rfe_type->ext_ant_switch_exist = true;
2033 rfe_type->ext_ant_switch_type =
2034 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2037 rfe_type->ext_ant_switch_exist = true;
2038 rfe_type->ext_ant_switch_type =
2039 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2042 rfe_type->ext_ant_switch_exist = true;
2043 rfe_type->ext_ant_switch_type =
2044 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2047 rfe_type->ext_ant_switch_exist = true;
2048 rfe_type->ext_ant_switch_type =
2049 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2052 rfe_type->ext_ant_switch_exist = true;
2053 rfe_type->ext_ant_switch_type =
2054 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT;
2059 /*anttenna control by bb mac bt antdiv pta to write 0x4c 0xcb4,0xcbd*/
2061 static void halbtc8822b1ant_set_ext_ant_switch(struct btc_coexist *btcoexist,
2062 bool force_exec, u8 ctrl_type,
2065 struct rtl_priv *rtlpriv = btcoexist->adapter;
2066 bool switch_polatiry_inverse = false;
2067 u8 regval_0xcbd = 0, regval_0x64;
2068 u32 u32tmp1 = 0, u32tmp2 = 0, u32tmp3 = 0;
2070 /* Ext switch buffer mux */
2071 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
2072 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x1991, 0x3, 0x0);
2073 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbe, 0x8, 0x0);
2075 if (!rfe_type->ext_ant_switch_exist)
2078 coex_dm->cur_ext_ant_switch_status = (ctrl_type << 8) + pos_type;
2081 if (coex_dm->pre_ext_ant_switch_status ==
2082 coex_dm->cur_ext_ant_switch_status)
2086 coex_dm->pre_ext_ant_switch_status = coex_dm->cur_ext_ant_switch_status;
2088 /* swap control polarity if use different switch control polarity*/
2089 /* Normal switch polarity for SPDT,
2090 * 0xcbd[1:0] = 2b'01 => Ant to BTG,
2091 * 0xcbd[1:0] = 2b'10 => Ant to WLG
2093 switch_polatiry_inverse = rfe_type->ext_ant_switch_ctrl_polarity == 1;
2097 case BT_8822B_1ANT_EXT_ANT_SWITCH_TO_BT:
2098 case BT_8822B_1ANT_EXT_ANT_SWITCH_TO_NOCARE:
2101 case BT_8822B_1ANT_EXT_ANT_SWITCH_TO_WLG:
2103 case BT_8822B_1ANT_EXT_ANT_SWITCH_TO_WLA:
2107 if (rfe_type->ext_ant_switch_type ==
2108 BT_8822B_1ANT_EXT_ANT_SWITCH_USE_SPDT) {
2109 switch (ctrl_type) {
2111 case BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_BBSW:
2113 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e,
2116 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4f,
2118 /* BB SW, DPDT use RFE_ctrl8 and RFE_ctrl9 as ctrl pin*/
2119 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb4,
2122 /* 0xcbd[1:0] = 2b'01 for no switch_polatiry_inverse,
2123 * ANTSWB =1, ANTSW =0
2125 regval_0xcbd = (!switch_polatiry_inverse ? 0x1 : 0x2);
2126 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd,
2130 case BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_PTA:
2132 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e,
2135 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4f,
2137 /* PTA, DPDT use RFE_ctrl8 and RFE_ctrl9 as ctrl pin */
2138 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb4,
2141 /* 0xcbd[1:0] = 2b'10 for no switch_polatiry_inverse,
2142 * ANTSWB =1, ANTSW =0 @ GNT_BT=1
2144 regval_0xcbd = (!switch_polatiry_inverse ? 0x2 : 0x1);
2145 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd,
2149 case BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_ANTDIV:
2151 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e,
2154 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4f,
2156 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb4,
2159 /* no regval_0xcbd setup required, because
2160 * antenna switch control value by antenna diversity
2164 case BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_MAC:
2166 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e,
2169 /* 0x64[0] = 1b'0 for no switch_polatiry_inverse,
2170 * DPDT_SEL_N =1, DPDT_SEL_P =0
2172 regval_0x64 = (!switch_polatiry_inverse ? 0x0 : 0x1);
2173 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
2176 case BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_BT:
2178 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e,
2181 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4f,
2184 /* no setup required, because antenna switch control
2185 * value by BT vendor 0xac[1:0]
2191 u32tmp1 = btcoexist->btc_read_4byte(btcoexist, 0xcbc);
2192 u32tmp2 = btcoexist->btc_read_4byte(btcoexist, 0x4c);
2193 u32tmp3 = btcoexist->btc_read_4byte(btcoexist, 0x64) & 0xff;
2196 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2197 "[BTCoex], ********** (After Ext Ant switch setup) 0xcbc = 0x%08x, 0x4c = 0x%08x, 0x64= 0x%02x**********\n",
2198 u32tmp1, u32tmp2, u32tmp3);
2201 /* set gnt_wl gnt_bt control by sw high low, or
2202 * hwpta while in power on, ini, wlan off, wlan only, wl2g non-currrent,
2203 * wl2g current, wl5g
2206 static void halbtc8822b1ant_set_ant_path(struct btc_coexist *btcoexist,
2207 u8 ant_pos_type, bool force_exec,
2211 struct rtl_priv *rtlpriv = btcoexist->adapter;
2214 u32 u32tmp2 = 0, u32tmp3 = 0;
2216 u32tmp1 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
2218 /* To avoid indirect access fail */
2219 if (((u32tmp1 & 0xf000) >> 12) != ((u32tmp1 & 0x0f00) >> 8)) {
2221 coex_sta->gnt_error_cnt++;
2223 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2224 "[BTCoex],(Before Ant Setup) 0x38= 0x%x\n", u32tmp1);
2227 /* Ext switch buffer mux */
2228 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
2229 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x1991, 0x3, 0x0);
2230 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbe, 0x8, 0x0);
2232 coex_dm->cur_ant_pos_type = (ant_pos_type << 8) + phase;
2235 if (coex_dm->cur_ant_pos_type == coex_dm->pre_ant_pos_type)
2239 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
2241 if (btcoexist->dbg_mode_1ant) {
2242 u32tmp1 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
2244 u32tmp2 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
2246 u32tmp3 = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
2248 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x73);
2251 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2252 "[BTCoex], ********** (Before Ant Setup) 0xcb4 = 0x%x, 0x73 = 0x%x, 0x38= 0x%x, 0x54= 0x%x**********\n",
2253 u32tmp3, u8tmp, u32tmp1, u32tmp2);
2257 case BT_8822B_1ANT_PHASE_COEX_INIT:
2259 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2260 "[BTCoex], ********** (set_ant_path - 1ANT_PHASE_COEX_INIT) **********\n");
2262 /* Disable LTE Coex Function in WiFi side
2263 * (this should be on if LTE coex is required)
2265 halbtc8822b1ant_ltecoex_enable(btcoexist, 0x0);
2267 /* GNT_WL_LTE always = 1
2268 * (this should be config if LTE coex is required)
2270 halbtc8822b1ant_ltecoex_set_coex_table(
2271 btcoexist, BT_8822B_1ANT_CTT_WL_VS_LTE, 0xffff);
2273 /* GNT_BT_LTE always = 1
2274 * (this should be config if LTE coex is required)
2276 halbtc8822b1ant_ltecoex_set_coex_table(
2277 btcoexist, BT_8822B_1ANT_CTT_BT_VS_LTE, 0xffff);
2279 /* set GNT_BT to SW high */
2280 halbtc8822b1ant_ltecoex_set_gnt_bt(
2281 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2282 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2283 BT_8822B_1ANT_SIG_STA_SET_TO_HIGH);
2285 /* set GNT_WL to SW low */
2286 halbtc8822b1ant_ltecoex_set_gnt_wl(
2287 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2288 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2289 BT_8822B_1ANT_SIG_STA_SET_TO_LOW);
2291 /* set Path control owner to WL at initial step */
2292 halbtc8822b1ant_ltecoex_pathcontrol_owner(
2293 btcoexist, BT_8822B_1ANT_PCO_WLSIDE);
2295 coex_sta->run_time_state = false;
2297 /* Ext switch buffer mux */
2298 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
2299 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x1991, 0x3, 0x0);
2300 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbe, 0x8, 0x0);
2302 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2303 ant_pos_type = BTC_ANT_PATH_BT;
2306 case BT_8822B_1ANT_PHASE_WLANONLY_INIT:
2308 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2309 "[BTCoex], ********** (set_ant_path - 1ANT_PHASE_WLANONLY_INIT) **********\n");
2311 /* Disable LTE Coex Function in WiFi side
2312 * (this should be on if LTE coex is required)
2314 halbtc8822b1ant_ltecoex_enable(btcoexist, 0x0);
2316 /* GNT_WL_LTE always = 1
2317 * (this should be config if LTE coex is required)
2319 halbtc8822b1ant_ltecoex_set_coex_table(
2320 btcoexist, BT_8822B_1ANT_CTT_WL_VS_LTE, 0xffff);
2322 /* GNT_BT_LTE always = 1
2323 * (this should be config if LTE coex is required)
2325 halbtc8822b1ant_ltecoex_set_coex_table(
2326 btcoexist, BT_8822B_1ANT_CTT_BT_VS_LTE, 0xffff);
2328 /* set GNT_BT to SW Low */
2329 halbtc8822b1ant_ltecoex_set_gnt_bt(
2330 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2331 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2332 BT_8822B_1ANT_SIG_STA_SET_TO_LOW);
2334 /* Set GNT_WL to SW high */
2335 halbtc8822b1ant_ltecoex_set_gnt_wl(
2336 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2337 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2338 BT_8822B_1ANT_SIG_STA_SET_TO_HIGH);
2340 /* set Path control owner to WL at initial step */
2341 halbtc8822b1ant_ltecoex_pathcontrol_owner(
2342 btcoexist, BT_8822B_1ANT_PCO_WLSIDE);
2344 coex_sta->run_time_state = false;
2346 /* Ext switch buffer mux */
2347 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
2348 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x1991, 0x3, 0x0);
2349 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbe, 0x8, 0x0);
2351 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2352 ant_pos_type = BTC_ANT_PATH_WIFI;
2355 case BT_8822B_1ANT_PHASE_WLAN_OFF:
2357 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2358 "[BTCoex], ********** (set_ant_path - 1ANT_PHASE_WLAN_OFF) **********\n");
2360 /* Disable LTE Coex Function in WiFi side */
2361 halbtc8822b1ant_ltecoex_enable(btcoexist, 0x0);
2363 /* set Path control owner to BT */
2364 halbtc8822b1ant_ltecoex_pathcontrol_owner(
2365 btcoexist, BT_8822B_1ANT_PCO_BTSIDE);
2367 /* Set Ext Ant Switch to BT control at wifi off step */
2368 halbtc8822b1ant_set_ext_ant_switch(
2369 btcoexist, FORCE_EXEC,
2370 BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_BT,
2371 BT_8822B_1ANT_EXT_ANT_SWITCH_TO_NOCARE);
2373 coex_sta->run_time_state = false;
2376 case BT_8822B_1ANT_PHASE_2G_RUNTIME:
2378 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2379 "[BTCoex], ********** (set_ant_path - 1ANT_PHASE_2G_RUNTIME) **********\n");
2381 /* set GNT_BT to PTA */
2382 halbtc8822b1ant_ltecoex_set_gnt_bt(
2383 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2384 BT_8822B_1ANT_GNT_CTRL_BY_PTA,
2385 BT_8822B_1ANT_SIG_STA_SET_BY_HW);
2387 /* Set GNT_WL to PTA */
2388 halbtc8822b1ant_ltecoex_set_gnt_wl(
2389 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2390 BT_8822B_1ANT_GNT_CTRL_BY_PTA,
2391 BT_8822B_1ANT_SIG_STA_SET_BY_HW);
2393 /* set Path control owner to WL at runtime step */
2394 halbtc8822b1ant_ltecoex_pathcontrol_owner(
2395 btcoexist, BT_8822B_1ANT_PCO_WLSIDE);
2397 coex_sta->run_time_state = true;
2399 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2400 ant_pos_type = BTC_ANT_PATH_PTA;
2403 case BT_8822B_1ANT_PHASE_5G_RUNTIME:
2405 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2406 "[BTCoex], ********** (set_ant_path - 1ANT_PHASE_5G_RUNTIME) **********\n");
2408 /* set GNT_BT to SW Hi */
2409 halbtc8822b1ant_ltecoex_set_gnt_bt(
2410 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2411 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2412 BT_8822B_1ANT_SIG_STA_SET_TO_HIGH);
2414 /* Set GNT_WL to SW Hi */
2415 halbtc8822b1ant_ltecoex_set_gnt_wl(
2416 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2417 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2418 BT_8822B_1ANT_SIG_STA_SET_TO_HIGH);
2420 /* set Path control owner to WL at runtime step */
2421 halbtc8822b1ant_ltecoex_pathcontrol_owner(
2422 btcoexist, BT_8822B_1ANT_PCO_WLSIDE);
2424 coex_sta->run_time_state = true;
2426 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2427 ant_pos_type = BTC_ANT_PATH_WIFI5G;
2430 case BT_8822B_1ANT_PHASE_BTMPMODE:
2432 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2433 "[BTCoex], ********** (set_ant_path - 1ANT_PHASE_BTMPMODE) **********\n");
2435 /* Disable LTE Coex Function in WiFi side */
2436 halbtc8822b1ant_ltecoex_enable(btcoexist, 0x0);
2438 /* set GNT_BT to SW Hi */
2439 halbtc8822b1ant_ltecoex_set_gnt_bt(
2440 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2441 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2442 BT_8822B_1ANT_SIG_STA_SET_TO_HIGH);
2444 /* Set GNT_WL to SW Lo */
2445 halbtc8822b1ant_ltecoex_set_gnt_wl(
2446 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
2447 BT_8822B_1ANT_GNT_CTRL_BY_SW,
2448 BT_8822B_1ANT_SIG_STA_SET_TO_LOW);
2450 /* set Path control owner to WL */
2451 halbtc8822b1ant_ltecoex_pathcontrol_owner(
2452 btcoexist, BT_8822B_1ANT_PCO_WLSIDE);
2454 coex_sta->run_time_state = false;
2456 /* Set Ext Ant Switch to BT side at BT MP mode */
2457 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2458 ant_pos_type = BTC_ANT_PATH_BT;
2463 if (phase != BT_8822B_1ANT_PHASE_WLAN_OFF) {
2464 switch (ant_pos_type) {
2465 case BTC_ANT_PATH_WIFI:
2466 halbtc8822b1ant_set_ext_ant_switch(
2467 btcoexist, force_exec,
2468 BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_BBSW,
2469 BT_8822B_1ANT_EXT_ANT_SWITCH_TO_WLG);
2471 case BTC_ANT_PATH_WIFI5G:
2472 halbtc8822b1ant_set_ext_ant_switch(
2473 btcoexist, force_exec,
2474 BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_BBSW,
2475 BT_8822B_1ANT_EXT_ANT_SWITCH_TO_WLA);
2477 case BTC_ANT_PATH_BT:
2478 halbtc8822b1ant_set_ext_ant_switch(
2479 btcoexist, force_exec,
2480 BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_BBSW,
2481 BT_8822B_1ANT_EXT_ANT_SWITCH_TO_BT);
2484 case BTC_ANT_PATH_PTA:
2485 halbtc8822b1ant_set_ext_ant_switch(
2486 btcoexist, force_exec,
2487 BT_8822B_1ANT_EXT_ANT_SWITCH_CTRL_BY_PTA,
2488 BT_8822B_1ANT_EXT_ANT_SWITCH_TO_NOCARE);
2493 if (btcoexist->dbg_mode_1ant) {
2494 u32tmp1 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
2496 u32tmp2 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
2498 u32tmp3 = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
2500 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x73);
2503 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2504 "[BTCoex], ********** (After Ant Setup) 0xcb4 = 0x%x, 0x73 = 0x%x, 0x38= 0x%x, 0x54= 0x%x**********\n",
2505 u32tmp3, u8tmp, u32tmp1, u32tmp2);
2509 static bool halbtc8822b1ant_is_common_action(struct btc_coexist *btcoexist)
2511 struct rtl_priv *rtlpriv = btcoexist->adapter;
2512 bool common = false, wifi_connected = false, wifi_busy = false;
2514 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2516 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2518 if (!wifi_connected &&
2519 coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_NON_CONNECTED_IDLE) {
2521 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2522 "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
2524 /* halbtc8822b1ant_sw_mechanism(btcoexist, false); */
2527 } else if (wifi_connected &&
2528 (coex_dm->bt_status ==
2529 BT_8822B_1ANT_BT_STATUS_NON_CONNECTED_IDLE)) {
2531 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2532 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
2534 /* halbtc8822b1ant_sw_mechanism(btcoexist, false); */
2537 } else if (!wifi_connected && (BT_8822B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2538 coex_dm->bt_status)) {
2540 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2541 "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
2543 /* halbtc8822b1ant_sw_mechanism(btcoexist, false); */
2546 } else if (wifi_connected && (BT_8822B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2547 coex_dm->bt_status)) {
2548 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2549 "[BTCoex], Wifi connected + BT connected-idle!!\n");
2551 /* halbtc8822b1ant_sw_mechanism(btcoexist, false); */
2554 } else if (!wifi_connected && (BT_8822B_1ANT_BT_STATUS_CONNECTED_IDLE !=
2555 coex_dm->bt_status)) {
2556 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2557 "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
2559 /* halbtc8822b1ant_sw_mechanism(btcoexist, false); */
2564 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2565 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
2567 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2568 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
2577 static void halbtc8822b1ant_action_wifi_under5g(struct btc_coexist *btcoexist)
2579 struct rtl_priv *rtlpriv = btcoexist->adapter;
2581 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2582 "[BTCoex], under 5g start\n");
2583 /* for test : s3 bt disappear , fail rate 1/600*/
2584 /*set sw gnt wl bt high*/
2585 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, FORCE_EXEC,
2586 BT_8822B_1ANT_PHASE_5G_RUNTIME);
2588 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2589 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2590 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd, 0x3, 1);
2593 static void halbtc8822b1ant_action_wifi_only(struct btc_coexist *btcoexist)
2595 struct rtl_priv *rtlpriv = btcoexist->adapter;
2596 bool wifi_under_5g = false, rf4ce_enabled = false;
2598 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2599 if (wifi_under_5g) {
2600 halbtc8822b1ant_action_wifi_under5g(btcoexist);
2603 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2604 "[BTCoex], ********** (wlan only -- under 5g ) **********\n");
2608 if (rf4ce_enabled) {
2609 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x45e, 0x8, 0x1);
2611 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 50);
2613 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2616 halbtc8822b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2617 halbtc8822b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2619 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, FORCE_EXEC,
2620 BT_8822B_1ANT_PHASE_2G_RUNTIME);
2622 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2623 "[BTCoex], ********** (wlan only -- under 2g ) **********\n");
2627 halbtc8822b1ant_action_wifi_native_lps(struct btc_coexist *btcoexist)
2629 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2631 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2634 /* *********************************************
2636 * Non-Software Coex Mechanism start
2638 * **********************************************/
2640 static void halbtc8822b1ant_action_bt_whck_test(struct btc_coexist *btcoexist)
2642 struct rtl_priv *rtlpriv = btcoexist->adapter;
2644 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2645 "[BTCoex],action_bt_whck_test\n");
2647 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2649 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
2650 BT_8822B_1ANT_PHASE_2G_RUNTIME);
2652 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2656 halbtc8822b1ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
2658 struct rtl_priv *rtlpriv = btcoexist->adapter;
2660 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2661 "[BTCoex],action_wifi_multi_port\n");
2663 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2665 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
2666 BT_8822B_1ANT_PHASE_2G_RUNTIME);
2668 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2671 static void halbtc8822b1ant_action_hs(struct btc_coexist *btcoexist)
2673 struct rtl_priv *rtlpriv = btcoexist->adapter;
2675 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], action_hs\n");
2677 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2679 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
2680 BT_8822B_1ANT_PHASE_2G_RUNTIME);
2682 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2685 static void halbtc8822b1ant_action_bt_relink(struct btc_coexist *btcoexist)
2687 struct rtl_priv *rtlpriv = btcoexist->adapter;
2689 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2690 "[BTCoex], run bt multi link function\n");
2692 if (coex_sta->is_bt_multi_link)
2694 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2695 "[BTCoex], run bt_re-link function\n");
2697 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2698 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2701 /*"""bt inquiry"""" + wifi any + bt any*/
2703 static void halbtc8822b1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
2705 struct rtl_priv *rtlpriv = btcoexist->adapter;
2706 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2707 bool wifi_connected = false, ap_enable = false, wifi_busy = false,
2708 bt_busy = false, rf4ce_enabled = false;
2710 bool wifi_scan = false, link = false, roam = false;
2712 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2713 "[BTCoex], ********** (bt inquiry) **********\n");
2714 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
2716 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2718 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2719 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2721 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
2722 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2723 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2726 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2727 "[BTCoex], ********** scan = %d, link =%d, roam = %d**********\n",
2728 wifi_scan, link, roam);
2730 if ((link) || (roam) || (coex_sta->wifi_is_high_pri_task)) {
2732 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2733 "[BTCoex], ********** (bt inquiry wifi connect or scan ) **********\n");
2735 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2737 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
2739 } else if ((wifi_scan) && (coex_sta->bt_create_connection)) {
2740 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
2741 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
2743 } else if ((!wifi_connected) && (!wifi_scan)) {
2745 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2746 "[BTCoex], ********** (bt inquiry wifi non connect) **********\n");
2748 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2750 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2752 } else if ((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) {
2753 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
2754 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2755 } else if (bt_link_info->a2dp_exist) {
2756 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2758 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2759 } else if (wifi_scan) {
2760 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
2762 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2763 } else if (wifi_busy) {
2764 /* for BT inquiry/page fail after S4 resume */
2765 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2766 /*aaaa->55aa for bt connect while wl busy*/
2767 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2769 if (rf4ce_enabled) {
2770 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x45e,
2773 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2776 halbtc8822b1ant_coex_table_with_type(btcoexist,
2781 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2782 "[BTCoex], ********** (bt inquiry wifi connect) **********\n");
2784 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
2786 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
2788 BT_8822B_1ANT_PHASE_2G_RUNTIME);
2790 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2795 halbtc8822b1ant_action_bt_sco_hid_only_busy(struct btc_coexist *btcoexist)
2797 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2798 bool wifi_connected = false, wifi_busy = false;
2801 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2804 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2806 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2808 if (bt_link_info->sco_exist) {
2809 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2810 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2812 if (coex_sta->is_hid_low_pri_tx_overhead) {
2813 halbtc8822b1ant_coex_table_with_type(btcoexist,
2815 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2817 } else if (wifi_bw == 0) { /* if 11bg mode */
2819 if (coex_sta->is_bt_multi_link) {
2820 halbtc8822b1ant_coex_table_with_type(
2821 btcoexist, NORMAL_EXEC, 11);
2822 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2825 halbtc8822b1ant_coex_table_with_type(
2826 btcoexist, NORMAL_EXEC, 6);
2827 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2831 halbtc8822b1ant_coex_table_with_type(btcoexist,
2833 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2840 halbtc8822b1ant_action_wifi_connected_bt_acl_busy(struct btc_coexist *btcoexist)
2842 struct rtl_priv *rtlpriv = btcoexist->adapter;
2843 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2844 bool wifi_busy = false, wifi_turbo = false;
2847 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2849 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2850 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2851 &coex_sta->scan_ap_num);
2853 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2854 "############# [BTCoex], scan_ap_num = %d, wl_noisy_level = %d\n",
2855 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2857 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2860 if ((coex_sta->bt_relink_downcount != 0) &&
2861 (!bt_link_info->pan_exist) && (wifi_busy)) {
2863 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2864 "############# [BTCoex], BT Re-Link + A2DP + WL busy\n");
2866 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2867 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2869 } else if ((bt_link_info->a2dp_exist) && (coex_sta->is_bt_a2dp_sink)) {
2870 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
2871 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
2872 } else if (bt_link_info->a2dp_only) { /* A2DP */
2874 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
2877 halbtc8822b1ant_coex_table_with_type(btcoexist,
2880 halbtc8822b1ant_coex_table_with_type(btcoexist,
2882 } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
2883 (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
2884 bt_link_info->pan_exist)) {
2885 /* A2DP+PAN(OPP,FTP), HID+A2DP+PAN(OPP,FTP) */
2888 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2891 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2894 if (bt_link_info->hid_exist)
2895 halbtc8822b1ant_coex_table_with_type(btcoexist,
2897 else if (wifi_turbo)
2898 halbtc8822b1ant_coex_table_with_type(btcoexist,
2901 halbtc8822b1ant_coex_table_with_type(btcoexist,
2903 } else if (bt_link_info->hid_exist &&
2904 bt_link_info->a2dp_exist) { /* HID+A2DP */
2906 if (wifi_bw == 0) { /* if 11bg mode */
2907 halbtc8822b1ant_coex_table_with_type(btcoexist,
2909 halbtc8822b1ant_set_wltoggle_coex_table(
2910 btcoexist, NORMAL_EXEC, 1, 0xaa, 0x5a, 0xaa,
2912 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2915 halbtc8822b1ant_coex_table_with_type(btcoexist,
2917 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC,
2919 halbtc8822b1ant_set_wltoggle_coex_table(
2920 btcoexist, NORMAL_EXEC, 1, 0xaa, 0x5a, 0xaa,
2922 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2925 /* PAN(OPP,FTP), HID+PAN(OPP,FTP) */
2927 } else if ((bt_link_info->pan_only) ||
2928 (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
2930 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2933 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2936 if (bt_link_info->hid_exist)
2937 halbtc8822b1ant_coex_table_with_type(btcoexist,
2939 else if (wifi_turbo)
2940 halbtc8822b1ant_coex_table_with_type(btcoexist,
2943 halbtc8822b1ant_coex_table_with_type(btcoexist,
2946 /* BT no-profile busy (0x9) */
2947 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
2948 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2952 /*wifi not connected + bt action*/
2955 halbtc8822b1ant_action_wifi_not_connected(struct btc_coexist *btcoexist)
2957 struct rtl_priv *rtlpriv = btcoexist->adapter;
2958 bool rf4ce_enabled = false;
2960 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2961 "[BTCoex], ********** (wifi not connect) **********\n");
2963 /* tdma and coex table */
2964 if (rf4ce_enabled) {
2965 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x45e, 0x8, 0x1);
2967 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 50);
2969 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2972 halbtc8822b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2974 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
2975 BT_8822B_1ANT_PHASE_2G_RUNTIME);
2977 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2980 /*""""wl not connected scan"""" + bt action*/
2982 halbtc8822b1ant_action_wifi_not_connected_scan(struct btc_coexist *btcoexist)
2984 struct rtl_priv *rtlpriv = btcoexist->adapter;
2985 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2986 bool bt_hs_on = false;
2987 u32 wifi_link_status = 0;
2988 u32 num_of_wifi_link = 0;
2989 bool bt_ctrl_agg_buf_size = false;
2990 u8 agg_buf_size = 5;
2992 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2993 "[BTCoex], ********** (wifi non connect scan) **********\n");
2995 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2996 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2999 num_of_wifi_link = wifi_link_status >> 16;
3001 if (num_of_wifi_link >= 2) {
3002 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3003 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3004 bt_ctrl_agg_buf_size, agg_buf_size);
3006 if (coex_sta->c2h_bt_inquiry_page) {
3007 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3008 "############# [BTCoex], BT Is Inquirying\n");
3009 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3011 halbtc8822b1ant_action_wifi_multi_port(btcoexist);
3016 if (coex_sta->c2h_bt_inquiry_page) {
3017 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3019 } else if (bt_hs_on) {
3020 halbtc8822b1ant_action_hs(btcoexist);
3024 /* tdma and coex table */
3025 if (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) {
3026 if (bt_link_info->a2dp_exist) {
3027 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3029 halbtc8822b1ant_coex_table_with_type(btcoexist,
3031 } else if (bt_link_info->a2dp_exist &&
3032 bt_link_info->pan_exist) {
3033 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3035 halbtc8822b1ant_coex_table_with_type(btcoexist,
3038 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3040 halbtc8822b1ant_coex_table_with_type(btcoexist,
3043 } else if ((coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_SCO_BUSY) ||
3044 (BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
3045 coex_dm->bt_status)) {
3046 halbtc8822b1ant_action_bt_sco_hid_only_busy(btcoexist);
3048 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
3050 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3052 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3054 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
3058 /*""""wl not connected asso"""" + bt action*/
3060 static void halbtc8822b1ant_action_wifi_not_connected_asso_auth(
3061 struct btc_coexist *btcoexist)
3063 struct rtl_priv *rtlpriv = btcoexist->adapter;
3064 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3065 bool bt_hs_on = false;
3066 u32 wifi_link_status = 0;
3067 u32 num_of_wifi_link = 0;
3068 bool bt_ctrl_agg_buf_size = false;
3069 u8 agg_buf_size = 5;
3072 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3073 "[BTCoex], ********** (wifi non connect asso_auth) **********\n");
3075 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3076 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3079 num_of_wifi_link = wifi_link_status >> 16;
3081 if (num_of_wifi_link >= 2) {
3082 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3083 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3084 bt_ctrl_agg_buf_size, agg_buf_size);
3086 if (coex_sta->c2h_bt_inquiry_page) {
3087 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3088 "############# [BTCoex], BT Is Inquirying\n");
3089 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3091 halbtc8822b1ant_action_wifi_multi_port(btcoexist);
3096 if (coex_sta->c2h_bt_inquiry_page) {
3097 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3099 } else if (bt_hs_on) {
3100 halbtc8822b1ant_action_hs(btcoexist);
3104 /* tdma and coex table */
3105 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
3106 (bt_link_info->a2dp_exist)) {
3107 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
3108 halbtc8822b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
3109 } else if (bt_link_info->pan_exist) {
3110 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
3111 halbtc8822b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
3113 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
3115 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3117 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3119 halbtc8822b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
3123 /*""""wl connected scan"""" + bt action*/
3126 halbtc8822b1ant_action_wifi_connected_scan(struct btc_coexist *btcoexist)
3128 struct rtl_priv *rtlpriv = btcoexist->adapter;
3129 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3130 bool bt_hs_on = false;
3131 u32 wifi_link_status = 0;
3132 u32 num_of_wifi_link = 0;
3133 bool bt_ctrl_agg_buf_size = false;
3134 u8 agg_buf_size = 5;
3136 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3137 "[BTCoex], ********** (wifi connect scan) **********\n");
3139 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3140 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3143 num_of_wifi_link = wifi_link_status >> 16;
3145 if (num_of_wifi_link >= 2) {
3146 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3147 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3148 bt_ctrl_agg_buf_size, agg_buf_size);
3150 if (coex_sta->c2h_bt_inquiry_page) {
3151 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3152 "############# [BTCoex], BT Is Inquirying\n");
3153 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3155 halbtc8822b1ant_action_wifi_multi_port(btcoexist);
3160 if (coex_sta->c2h_bt_inquiry_page) {
3161 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3163 } else if (bt_hs_on) {
3164 halbtc8822b1ant_action_hs(btcoexist);
3168 /* tdma and coex table */
3169 if (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) {
3170 if (bt_link_info->a2dp_exist) {
3171 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3173 halbtc8822b1ant_coex_table_with_type(btcoexist,
3175 } else if (bt_link_info->a2dp_exist &&
3176 bt_link_info->pan_exist) {
3177 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3179 halbtc8822b1ant_coex_table_with_type(btcoexist,
3182 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3184 halbtc8822b1ant_coex_table_with_type(btcoexist,
3187 } else if ((coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_SCO_BUSY) ||
3188 (BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
3189 coex_dm->bt_status)) {
3190 halbtc8822b1ant_action_bt_sco_hid_only_busy(btcoexist);
3192 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
3194 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3196 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3198 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
3202 /*""""wl connected specific packet"""" + bt action*/
3204 static void halbtc8822b1ant_action_wifi_connected_specific_packet(
3205 struct btc_coexist *btcoexist)
3207 struct rtl_priv *rtlpriv = btcoexist->adapter;
3208 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3209 bool bt_hs_on = false;
3210 u32 wifi_link_status = 0;
3211 u32 num_of_wifi_link = 0;
3212 bool bt_ctrl_agg_buf_size = false;
3213 u8 agg_buf_size = 5;
3214 bool wifi_busy = false;
3217 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3218 "[BTCoex], ********** (wifi connect specific packet) **********\n");
3220 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3221 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3224 num_of_wifi_link = wifi_link_status >> 16;
3226 if (num_of_wifi_link >= 2) {
3227 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3228 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3229 bt_ctrl_agg_buf_size, agg_buf_size);
3231 if (coex_sta->c2h_bt_inquiry_page) {
3232 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3233 "############# [BTCoex], BT Is Inquirying\n");
3234 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3236 halbtc8822b1ant_action_wifi_multi_port(btcoexist);
3241 if (coex_sta->c2h_bt_inquiry_page) {
3242 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3244 } else if (bt_hs_on) {
3245 halbtc8822b1ant_action_hs(btcoexist);
3249 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3251 /* no specific packet process for both WiFi and BT very busy */
3253 ((bt_link_info->pan_exist) || (coex_sta->num_of_profile >= 2)))
3256 /* tdma and coex table */
3257 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
3258 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
3259 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
3260 } else if (bt_link_info->a2dp_exist) {
3261 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
3262 /*for a2dp glitch,change from 1 to 15*/
3263 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3265 } else if (bt_link_info->pan_exist) {
3266 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
3267 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3269 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
3271 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3273 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3275 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
3279 /* wifi connected input point:
3280 * to set different ps and tdma case (+bt different case)
3283 static void halbtc8822b1ant_action_wifi_connected(struct btc_coexist *btcoexist)
3285 struct rtl_priv *rtlpriv = btcoexist->adapter;
3286 bool wifi_busy = false, rf4ce_enabled = false;
3287 bool scan = false, link = false, roam = false;
3288 bool under_4way = false, ap_enable = false, wifi_under_5g = false;
3291 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3292 "[BTCoex], CoexForWifiConnect()===>\n");
3294 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3296 if (wifi_under_5g) {
3298 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3299 "[BTCoex], CoexForWifiConnect(), return for wifi is under 5g<===\n");
3301 halbtc8822b1ant_action_wifi_under5g(btcoexist);
3307 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3308 "[BTCoex], CoexForWifiConnect(), return for wifi is under 2g<===\n");
3310 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
3311 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3313 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3317 halbtc8822b1ant_action_wifi_connected_specific_packet(
3320 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3321 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
3325 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3326 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3327 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3328 if (scan || link || roam) {
3330 halbtc8822b1ant_action_wifi_connected_scan(btcoexist);
3332 halbtc8822b1ant_action_wifi_connected_specific_packet(
3335 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3336 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
3340 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
3342 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3344 /* tdma and coex table */
3346 if (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) {
3347 halbtc8822b1ant_action_wifi_connected_bt_acl_busy(
3349 } else if ((BT_8822B_1ANT_BT_STATUS_SCO_BUSY ==
3350 coex_dm->bt_status) ||
3351 (BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
3352 coex_dm->bt_status)) {
3353 halbtc8822b1ant_action_bt_sco_hid_only_busy(btcoexist);
3355 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
3358 halbtc8822b1ant_set_ant_path(
3359 btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
3360 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3362 if ((coex_sta->high_priority_tx) +
3363 (coex_sta->high_priority_rx) <=
3365 /*sy modify case16 -> case17*/
3366 halbtc8822b1ant_coex_table_with_type(
3367 btcoexist, NORMAL_EXEC, 1);
3369 halbtc8822b1ant_coex_table_with_type(
3370 btcoexist, NORMAL_EXEC, 1);
3373 if (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) {
3374 halbtc8822b1ant_action_wifi_connected_bt_acl_busy(
3376 } else if ((BT_8822B_1ANT_BT_STATUS_SCO_BUSY ==
3377 coex_dm->bt_status) ||
3378 (BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
3379 coex_dm->bt_status)) {
3380 halbtc8822b1ant_action_bt_sco_hid_only_busy(btcoexist);
3382 if (rf4ce_enabled) {
3383 btcoexist->btc_write_1byte_bitmask(
3384 btcoexist, 0x45e, 0x8, 0x1);
3386 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
3389 halbtc8822b1ant_coex_table_with_type(
3390 btcoexist, NORMAL_EXEC, 1);
3394 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
3397 halbtc8822b1ant_set_ant_path(
3398 btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
3399 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3401 wifi_rssi_state = halbtc8822b1ant_wifi_rssi_state(
3402 btcoexist, 1, 2, 25, 0);
3404 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3405 "[BTCoex], ********** before **********\n");
3406 if (BT_8822B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3407 coex_dm->bt_status) {
3408 if (rf4ce_enabled) {
3409 btcoexist->btc_write_1byte_bitmask(
3410 btcoexist, 0x45e, 0x8, 0x1);
3412 halbtc8822b1ant_ps_tdma(btcoexist,
3416 halbtc8822b1ant_coex_table_with_type(
3417 btcoexist, NORMAL_EXEC, 1);
3421 halbtc8822b1ant_coex_table_with_type(
3422 btcoexist, NORMAL_EXEC, 1);
3424 halbtc8822b1ant_coex_table_with_type(
3425 btcoexist, NORMAL_EXEC, 1);
3432 halbtc8822b1ant_run_sw_coexist_mechanism(struct btc_coexist *btcoexist)
3434 struct rtl_priv *rtlpriv = btcoexist->adapter;
3437 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3438 "[BTCoex], ********** (run sw coexmech) **********\n");
3439 algorithm = halbtc8822b1ant_action_algorithm(btcoexist);
3440 coex_dm->cur_algorithm = algorithm;
3442 if (halbtc8822b1ant_is_common_action(btcoexist)) {
3444 switch (coex_dm->cur_algorithm) {
3445 case BT_8822B_1ANT_COEX_ALGO_SCO:
3446 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3447 "[BTCoex], Action algorithm = SCO.\n");
3449 case BT_8822B_1ANT_COEX_ALGO_HID:
3450 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3451 "[BTCoex], Action algorithm = HID.\n");
3453 case BT_8822B_1ANT_COEX_ALGO_A2DP:
3454 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3455 "[BTCoex], Action algorithm = A2DP.\n");
3457 case BT_8822B_1ANT_COEX_ALGO_A2DP_PANHS:
3459 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3460 "[BTCoex], Action algorithm = A2DP+PAN(HS).\n");
3462 case BT_8822B_1ANT_COEX_ALGO_PANEDR:
3463 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3464 "[BTCoex], Action algorithm = PAN(EDR).\n");
3466 case BT_8822B_1ANT_COEX_ALGO_PANHS:
3467 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3468 "[BTCoex], Action algorithm = HS mode.\n");
3470 case BT_8822B_1ANT_COEX_ALGO_PANEDR_A2DP:
3471 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3472 "[BTCoex], Action algorithm = PAN+A2DP.\n");
3474 case BT_8822B_1ANT_COEX_ALGO_PANEDR_HID:
3476 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3477 "[BTCoex], Action algorithm = PAN(EDR)+HID.\n");
3479 case BT_8822B_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
3481 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3482 "[BTCoex], Action algorithm = HID+A2DP+PAN.\n");
3484 case BT_8822B_1ANT_COEX_ALGO_HID_A2DP:
3485 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3486 "[BTCoex], Action algorithm = HID+A2DP.\n");
3490 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3491 "[BTCoex], Action algorithm = coexist All Off!!\n");
3494 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3498 static void halbtc8822b1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3500 struct rtl_priv *rtlpriv = btcoexist->adapter;
3501 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3502 bool wifi_connected = false, bt_hs_on = false;
3503 bool increase_scan_dev_num = false;
3504 bool bt_ctrl_agg_buf_size = false;
3505 bool miracast_plus_bt = false;
3506 u8 agg_buf_size = 5;
3507 u32 wifi_link_status = 0;
3508 u32 num_of_wifi_link = 0, wifi_bw;
3509 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
3510 bool wifi_under_5g = false;
3512 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3513 "[BTCoex], RunCoexistMechanism()===>\n");
3515 if (btcoexist->manual_control) {
3517 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3518 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3522 if (btcoexist->stop_coex_dm) {
3524 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3525 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
3529 if (coex_sta->under_ips) {
3530 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3531 "[BTCoex], wifi is under IPS !!!\n");
3535 if ((coex_sta->under_lps) &&
3536 (coex_dm->bt_status != BT_8822B_1ANT_BT_STATUS_ACL_BUSY)) {
3538 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3539 "[BTCoex], RunCoexistMechanism(), wifi is under LPS !!!\n");
3540 halbtc8822b1ant_action_wifi_native_lps(btcoexist);
3544 if (!coex_sta->run_time_state) {
3545 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3546 "[BTCoex], return for run_time_state = false !!!\n");
3550 if (coex_sta->freeze_coexrun_by_btinfo) {
3552 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3553 "[BTCoex], BtInfoNotify(), return for freeze_coexrun_by_btinfo\n");
3557 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3558 if (wifi_under_5g) {
3559 halbtc8822b1ant_action_wifi_under5g(btcoexist);
3561 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3562 "[BTCoex], WiFi is under 5G!!!\n");
3566 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3567 "[BTCoex], WiFi is under 2G!!!\n");
3569 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
3570 BT_8822B_1ANT_PHASE_2G_RUNTIME);
3572 if (coex_sta->bt_whck_test) {
3573 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3574 "[BTCoex], BT is under WHCK TEST!!!\n");
3575 halbtc8822b1ant_action_bt_whck_test(btcoexist);
3579 if (coex_sta->bt_disabled) {
3580 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3581 "[BTCoex], BT is disabled !!!\n");
3582 halbtc8822b1ant_action_wifi_only(btcoexist);
3586 if (coex_sta->is_setup_link) {
3587 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3588 "[BTCoex], BT is re-link !!!\n");
3589 halbtc8822b1ant_action_bt_relink(btcoexist);
3593 if ((coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_BUSY) ||
3594 (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_SCO_BUSY) ||
3595 (coex_dm->bt_status == BT_8822B_1ANT_BT_STATUS_ACL_SCO_BUSY))
3596 increase_scan_dev_num = true;
3598 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
3599 &increase_scan_dev_num);
3600 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3603 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3605 num_of_wifi_link = wifi_link_status >> 16;
3607 if ((num_of_wifi_link >= 2) ||
3608 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3610 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3611 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3612 num_of_wifi_link, wifi_link_status);
3614 if (bt_link_info->bt_link_exist) {
3615 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1,
3617 miracast_plus_bt = true;
3619 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0,
3621 miracast_plus_bt = false;
3623 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3625 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
3626 bt_ctrl_agg_buf_size, agg_buf_size);
3628 if ((bt_link_info->a2dp_exist) &&
3629 (coex_sta->c2h_bt_inquiry_page)) {
3630 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3631 "############# [BTCoex], BT Is Inquirying\n");
3632 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3634 halbtc8822b1ant_action_wifi_multi_port(btcoexist);
3640 miracast_plus_bt = false;
3641 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3644 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3646 if ((bt_link_info->bt_link_exist) && (wifi_connected)) {
3647 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 0, 1);
3649 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
3651 if (iot_peer != BTC_IOT_PEER_CISCO) {
3652 if (bt_link_info->sco_exist)
3653 halbtc8822b1ant_limited_rx(btcoexist,
3657 halbtc8822b1ant_limited_rx(btcoexist,
3661 if (bt_link_info->sco_exist) {
3662 halbtc8822b1ant_limited_rx(btcoexist,
3666 if (wifi_bw == BTC_WIFI_BW_HT40)
3667 halbtc8822b1ant_limited_rx(
3668 btcoexist, NORMAL_EXEC, false,
3671 halbtc8822b1ant_limited_rx(
3672 btcoexist, NORMAL_EXEC, false,
3677 halbtc8822b1ant_sw_mechanism(btcoexist, true);
3678 halbtc8822b1ant_run_sw_coexist_mechanism(
3679 btcoexist); /* just print debug message */
3681 halbtc8822b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
3683 halbtc8822b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
3686 halbtc8822b1ant_sw_mechanism(btcoexist, false);
3687 halbtc8822b1ant_run_sw_coexist_mechanism(
3688 btcoexist); /* just print debug message */
3691 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3692 if (coex_sta->c2h_bt_inquiry_page) {
3693 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3694 "############# [BTCoex], BT Is Inquirying\n");
3695 halbtc8822b1ant_action_bt_inquiry(btcoexist);
3697 } else if (bt_hs_on) {
3698 halbtc8822b1ant_action_hs(btcoexist);
3702 if (!wifi_connected) {
3703 bool scan = false, link = false, roam = false;
3705 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3706 "[BTCoex], wifi is non connected-idle !!!\n");
3708 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3709 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3710 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3713 halbtc8822b1ant_action_wifi_not_connected_scan(
3715 else if (link || roam)
3716 halbtc8822b1ant_action_wifi_not_connected_asso_auth(
3719 halbtc8822b1ant_action_wifi_not_connected(btcoexist);
3720 } else { /* wifi LPS/Busy */
3721 halbtc8822b1ant_action_wifi_connected(btcoexist);
3725 static void halbtc8822b1ant_init_coex_dm(struct btc_coexist *btcoexist)
3727 /* force to reset coex mechanism */
3729 halbtc8822b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, false);
3732 halbtc8822b1ant_sw_mechanism(btcoexist, false);
3734 coex_sta->pop_event_cnt = 0;
3737 static void halbtc8822b1ant_init_hw_config(struct btc_coexist *btcoexist,
3738 bool back_up, bool wifi_only)
3740 struct rtl_priv *rtlpriv = btcoexist->adapter;
3741 u8 u8tmp = 0, i = 0;
3742 u32 u32tmp1 = 0, u32tmp2 = 0, u32tmp3 = 0;
3744 u32tmp3 = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
3745 u32tmp1 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
3746 u32tmp2 = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
3749 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3750 "[BTCoex], ********** (Before Init HW config) 0xcb4 = 0x%x, 0x38= 0x%x, 0x54= 0x%x**********\n",
3751 u32tmp3, u32tmp1, u32tmp2);
3753 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3754 "[BTCoex], 1Ant Init HW Config!!\n");
3756 coex_sta->bt_coex_supported_feature = 0;
3757 coex_sta->bt_coex_supported_version = 0;
3758 coex_sta->bt_ble_scan_type = 0;
3759 coex_sta->bt_ble_scan_para[0] = 0;
3760 coex_sta->bt_ble_scan_para[1] = 0;
3761 coex_sta->bt_ble_scan_para[2] = 0;
3762 coex_sta->bt_reg_vendor_ac = 0xffff;
3763 coex_sta->bt_reg_vendor_ae = 0xffff;
3764 coex_sta->isolation_btween_wb = BT_8822B_1ANT_DEFAULT_ISOLATION;
3765 coex_sta->gnt_error_cnt = 0;
3766 coex_sta->bt_relink_downcount = 0;
3767 coex_sta->is_set_ps_state_fail = false;
3768 coex_sta->cnt_set_ps_state_fail = 0;
3770 for (i = 0; i <= 9; i++)
3771 coex_sta->bt_afh_map[i] = 0;
3773 /* Setup RF front end type */
3774 halbtc8822b1ant_set_rfe_type(btcoexist);
3776 /* 0xf0[15:12] --> Chip Cut information */
3777 coex_sta->cut_version =
3778 (btcoexist->btc_read_1byte(btcoexist, 0xf1) & 0xf0) >> 4;
3780 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
3781 0x1); /* enable TBTT nterrupt */
3783 /* BT report packet sample rate */
3784 /* 0x790[5:0]=0x5 */
3785 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3788 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3790 /* Enable BT counter statistics */
3791 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
3793 /* Enable PTA (3-wire function form BT side) */
3794 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3795 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x41, 0x02, 0x1);
3797 /* Enable PTA (tx/rx signal form WiFi side) */
3798 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4c6, 0x10, 0x1);
3799 /*GNT_BT=1 while select both */
3800 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x763, 0x10, 0x1);
3803 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x0);
3804 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x0);
3806 if (btcoexist->btc_read_1byte(btcoexist, 0x80) == 0xc6)
3807 halbtc8822b1ant_post_state_to_bt(
3808 btcoexist, BT_8822B_1ANT_SCOREBOARD_ONOFF, true);
3810 /* Antenna config */
3811 if (coex_sta->is_rf_state_off) {
3812 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3814 BT_8822B_1ANT_PHASE_WLAN_OFF);
3816 btcoexist->stop_coex_dm = true;
3818 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3819 "[BTCoex], ********** %s (RF Off)**********\n",
3821 } else if (wifi_only) {
3822 coex_sta->concurrent_rx_mode_on = false;
3823 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
3825 BT_8822B_1ANT_PHASE_WLANONLY_INIT);
3827 coex_sta->concurrent_rx_mode_on = true;
3829 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3831 BT_8822B_1ANT_PHASE_COEX_INIT);
3835 halbtc8822b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3837 halbtc8822b1ant_enable_gnt_to_gpio(btcoexist, true);
3840 void ex_btc8822b1ant_power_on_setting(struct btc_coexist *btcoexist)
3842 struct rtl_priv *rtlpriv = btcoexist->adapter;
3843 struct btc_board_info *board_info = &btcoexist->board_info;
3848 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3849 "xxxxxxxxxxxxxxxx Execute 8822b 1-Ant PowerOn Setting!! xxxxxxxxxxxxxxxx\n");
3851 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3852 "Ant Det Finish = %s, Ant Det Number = %d\n",
3853 board_info->btdm_ant_det_finish ? "Yes" : "No",
3854 board_info->btdm_ant_num_by_ant_det);
3856 btcoexist->dbg_mode_1ant = false;
3857 btcoexist->stop_coex_dm = true;
3859 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
3860 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
3861 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
3863 /* set Path control owner to WiFi */
3864 halbtc8822b1ant_ltecoex_pathcontrol_owner(btcoexist,
3865 BT_8822B_1ANT_PCO_WLSIDE);
3867 /* set GNT_BT to high */
3868 halbtc8822b1ant_ltecoex_set_gnt_bt(btcoexist,
3869 BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
3870 BT_8822B_1ANT_GNT_CTRL_BY_SW,
3871 BT_8822B_1ANT_SIG_STA_SET_TO_HIGH);
3872 /* Set GNT_WL to low */
3873 halbtc8822b1ant_ltecoex_set_gnt_wl(
3874 btcoexist, BT_8822B_1ANT_GNT_BLOCK_RFC_BB,
3875 BT_8822B_1ANT_GNT_CTRL_BY_SW, BT_8822B_1ANT_SIG_STA_SET_TO_LOW);
3877 /* set WLAN_ACT = 0 */
3878 /* btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4); */
3880 /* SD1 Chunchu red x issue */
3881 btcoexist->btc_write_1byte(btcoexist, 0xff1a, 0x0);
3883 halbtc8822b1ant_enable_gnt_to_gpio(btcoexist, true);
3886 /* S0 or S1 setting and Local register setting
3887 * (By the setting fw can get ant number, S0/S1, ... info)
3889 /* Local setting bit define */
3890 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
3891 /* BIT1: "0" for internal switch; "1" for external switch */
3892 /* BIT2: "0" for one antenna; "1" for two antenna */
3893 /* NOTE: here default all internal switch and 1-antenna ==>
3898 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3900 if (btcoexist->chip_interface == BTC_INTF_USB)
3901 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3902 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3903 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60, u8tmp);
3906 void ex_btc8822b1ant_pre_load_firmware(struct btc_coexist *btcoexist) {}
3908 void ex_btc8822b1ant_init_hw_config(struct btc_coexist *btcoexist,
3911 struct rtl_priv *rtlpriv = btcoexist->adapter;
3913 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3914 "[BTCoex], ********** (ini hw config) **********\n");
3916 halbtc8822b1ant_init_hw_config(btcoexist, true, wifi_only);
3917 btcoexist->stop_coex_dm = false;
3918 btcoexist->auto_report_1ant = true;
3921 void ex_btc8822b1ant_init_coex_dm(struct btc_coexist *btcoexist)
3923 struct rtl_priv *rtlpriv = btcoexist->adapter;
3925 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3926 "[BTCoex], Coex Mechanism Init!!\n");
3928 btcoexist->stop_coex_dm = false;
3930 halbtc8822b1ant_init_coex_dm(btcoexist);
3932 halbtc8822b1ant_query_bt_info(btcoexist);
3935 void ex_btc8822b1ant_display_coex_info(struct btc_coexist *btcoexist,
3938 struct btc_board_info *board_info = &btcoexist->board_info;
3939 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3941 u8 u8tmp[4], i, ps_tdma_case = 0;
3944 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck;
3945 u32 fw_ver = 0, bt_patch_ver = 0, bt_coex_ver = 0;
3946 static u8 pop_report_in_10s;
3948 bool lte_coex_on = false;
3951 seq_puts(m, "\r\n ============[BT Coexist info]============");
3953 if (btcoexist->manual_control) {
3955 "\r\n ============[Under Manual Control]============");
3956 seq_puts(m, "\r\n ==========================================");
3958 if (btcoexist->stop_coex_dm) {
3959 seq_puts(m, "\r\n ============[Coex is STOPPED]============");
3960 seq_puts(m, "\r\n ==========================================");
3963 if (!coex_sta->bt_disabled) {
3964 if (coex_sta->bt_coex_supported_feature == 0)
3966 btcoexist, BTC_GET_U4_SUPPORTED_FEATURE,
3967 &coex_sta->bt_coex_supported_feature);
3969 if ((coex_sta->bt_coex_supported_version == 0) ||
3970 (coex_sta->bt_coex_supported_version == 0xffff))
3972 btcoexist, BTC_GET_U4_SUPPORTED_VERSION,
3973 &coex_sta->bt_coex_supported_version);
3975 if (coex_sta->bt_reg_vendor_ac == 0xffff)
3976 coex_sta->bt_reg_vendor_ac = (u16)(
3977 btcoexist->btc_get_bt_reg(btcoexist, 3, 0xac) &
3980 if (coex_sta->bt_reg_vendor_ae == 0xffff)
3981 coex_sta->bt_reg_vendor_ae = (u16)(
3982 btcoexist->btc_get_bt_reg(btcoexist, 3, 0xae) &
3985 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3987 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
3989 if (coex_sta->num_of_profile > 0) {
3993 btcoexist->btc_get_bt_afh_map_from_bt(
3994 btcoexist, 0, &coex_sta->bt_afh_map[0]);
4000 if (psd_scan->ant_det_try_count == 0) {
4002 m, "\r\n %-35s = %d/ %d/ %s / %d",
4003 "Ant PG Num/ Mech/ Pos/ RFE", board_info->pg_ant_num,
4004 board_info->btdm_ant_num,
4005 (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT ?
4008 rfe_type->rfe_module_type);
4011 m, "\r\n %-35s = %d/ %d/ %s/ %d (%d/%d/%d)",
4012 "Ant PG Num/ Mech(Ant_Det)/ Pos/ RFE",
4013 board_info->pg_ant_num,
4014 board_info->btdm_ant_num_by_ant_det,
4015 (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT ?
4018 rfe_type->rfe_module_type, psd_scan->ant_det_try_count,
4019 psd_scan->ant_det_fail_count, psd_scan->ant_det_result);
4021 if (board_info->btdm_ant_det_finish) {
4022 if (psd_scan->ant_det_result != 12)
4023 seq_printf(m, "\r\n %-35s = %s",
4024 "Ant Det PSD Value",
4025 psd_scan->ant_det_peak_val);
4027 seq_printf(m, "\r\n %-35s = %d",
4028 "Ant Det PSD Value",
4029 psd_scan->ant_det_psd_scan_peak_val /
4034 bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
4035 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
4036 phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
4038 bt_coex_ver = ((coex_sta->bt_coex_supported_version & 0xff00) >> 8);
4041 m, "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
4042 "CoexVer WL/ BT_Desired/ BT_Report",
4043 glcoex_ver_date_8822b_1ant, glcoex_ver_8822b_1ant,
4044 glcoex_ver_btdesired_8822b_1ant, bt_coex_ver,
4045 (bt_coex_ver == 0xff ?
4047 (coex_sta->bt_disabled ? "BT-disable" :
4048 (bt_coex_ver >= glcoex_ver_btdesired_8822b_1ant ?
4052 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c", "W_FW/ B_FW/ Phy/ Kt",
4053 fw_ver, bt_patch_ver, phyver, coex_sta->cut_version + 65);
4055 seq_printf(m, "\r\n %-35s = %02x %02x %02x ", "AFH Map to BT",
4056 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
4057 coex_dm->wifi_chnl_info[2]);
4060 seq_printf(m, "\r\n %-35s", "============[Wifi Status]============");
4061 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS, m);
4063 seq_printf(m, "\r\n %-35s", "============[BT Status]============");
4065 pop_report_in_10s++;
4067 m, "\r\n %-35s = [%s/ %d dBm/ %d/ %d] ",
4068 "BT [status/ rssi/ retryCnt/ popCnt]",
4069 ((coex_sta->bt_disabled) ?
4071 ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page") :
4072 ((BT_8822B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
4073 coex_dm->bt_status) ?
4074 "non-connected idle" :
4075 ((coex_dm->bt_status ==
4076 BT_8822B_1ANT_BT_STATUS_CONNECTED_IDLE) ?
4079 coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
4080 coex_sta->pop_event_cnt);
4082 if (pop_report_in_10s >= 5) {
4083 coex_sta->pop_event_cnt = 0;
4084 pop_report_in_10s = 0;
4087 if (coex_sta->num_of_profile != 0)
4089 m, "\r\n %-35s = %s%s%s%s%s", "Profiles",
4090 ((bt_link_info->a2dp_exist) ?
4091 ((coex_sta->is_bt_a2dp_sink) ? "A2DP sink," :
4094 ((bt_link_info->sco_exist) ? "HFP," : ""),
4095 ((bt_link_info->hid_exist) ?
4096 ((coex_sta->hid_busy_num >= 2) ?
4100 ((bt_link_info->pan_exist) ? "PAN," : ""),
4101 ((coex_sta->voice_over_HOGP) ? "Voice" : ""));
4103 seq_printf(m, "\r\n %-35s = None", "Profiles");
4105 if (bt_link_info->a2dp_exist) {
4106 seq_printf(m, "\r\n %-35s = %s/ %d/ %s",
4107 "A2DP Rate/Bitpool/Auto_Slot",
4108 ((coex_sta->is_A2DP_3M) ? "3M" : "No_3M"),
4109 coex_sta->a2dp_bit_pool,
4110 ((coex_sta->is_autoslot) ? "On" : "Off"));
4113 if (bt_link_info->hid_exist) {
4114 seq_printf(m, "\r\n %-35s = %d/ %d", "HID PairNum/Forbid_Slot",
4115 coex_sta->hid_pair_cnt, coex_sta->forbidden_slot);
4118 seq_printf(m, "\r\n %-35s = %s/ %d/ %s/ 0x%x",
4119 "Role/RoleSwCnt/IgnWlact/Feature",
4120 ((bt_link_info->slave_role) ? "Slave" : "Master"),
4121 coex_sta->cnt_role_switch,
4122 ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
4123 coex_sta->bt_coex_supported_feature);
4125 if ((coex_sta->bt_ble_scan_type & 0x7) != 0x0) {
4126 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4127 "BLEScan Type/TV/Init/Ble",
4128 coex_sta->bt_ble_scan_type,
4129 (coex_sta->bt_ble_scan_type & 0x1 ?
4130 coex_sta->bt_ble_scan_para[0] :
4132 (coex_sta->bt_ble_scan_type & 0x2 ?
4133 coex_sta->bt_ble_scan_para[1] :
4135 (coex_sta->bt_ble_scan_type & 0x4 ?
4136 coex_sta->bt_ble_scan_para[2] :
4140 seq_printf(m, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
4141 "ReInit/ReLink/IgnWlact/Page/NameReq", coex_sta->cnt_reinit,
4142 coex_sta->cnt_setup_link, coex_sta->cnt_ign_wlan_act,
4143 coex_sta->cnt_page, coex_sta->cnt_remote_name_req);
4145 halbtc8822b1ant_read_score_board(btcoexist, &u16tmp[0]);
4147 if ((coex_sta->bt_reg_vendor_ae == 0xffff) ||
4148 (coex_sta->bt_reg_vendor_ac == 0xffff))
4149 seq_printf(m, "\r\n %-35s = x/ x/ %04x",
4150 "0xae[4]/0xac[1:0]/Scoreboard", u16tmp[0]);
4152 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ %04x",
4153 "0xae[4]/0xac[1:0]/Scoreboard",
4154 (int)((coex_sta->bt_reg_vendor_ae & BIT(4)) >> 4),
4155 coex_sta->bt_reg_vendor_ac & 0x3, u16tmp[0]);
4157 if (coex_sta->num_of_profile > 0) {
4160 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
4161 "AFH MAP", coex_sta->bt_afh_map[0],
4162 coex_sta->bt_afh_map[1], coex_sta->bt_afh_map[2],
4163 coex_sta->bt_afh_map[3], coex_sta->bt_afh_map[4],
4164 coex_sta->bt_afh_map[5], coex_sta->bt_afh_map[6],
4165 coex_sta->bt_afh_map[7], coex_sta->bt_afh_map[8],
4166 coex_sta->bt_afh_map[9]);
4169 for (i = 0; i < BT_INFO_SRC_8822B_1ANT_MAX; i++) {
4170 if (coex_sta->bt_info_c2h_cnt[i]) {
4173 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)",
4174 glbt_info_src_8822b_1ant[i],
4175 coex_sta->bt_info_c2h[i][0],
4176 coex_sta->bt_info_c2h[i][1],
4177 coex_sta->bt_info_c2h[i][2],
4178 coex_sta->bt_info_c2h[i][3],
4179 coex_sta->bt_info_c2h[i][4],
4180 coex_sta->bt_info_c2h[i][5],
4181 coex_sta->bt_info_c2h[i][6],
4182 coex_sta->bt_info_c2h_cnt[i]);
4186 if (btcoexist->manual_control)
4189 "============[mechanisms] (before Manual)============");
4191 seq_printf(m, "\r\n %-35s",
4192 "============[Mechanisms]============");
4194 ps_tdma_case = coex_dm->cur_ps_tdma;
4195 seq_printf(m, "\r\n %-35s = %02x %02x %02x %02x %02x (case-%d, %s)",
4196 "TDMA", coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
4197 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
4198 coex_dm->ps_tdma_para[4], ps_tdma_case,
4199 (coex_dm->cur_ps_tdma_on ? "TDMA On" : "TDMA Off"));
4201 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
4202 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
4203 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
4204 seq_printf(m, "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
4205 "Table/0x6c0/0x6c4/0x6c8", coex_sta->coex_table_type,
4206 u32tmp[0], u32tmp[1], u32tmp[2]);
4208 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
4209 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
4210 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x", "0x778/0x6cc", u8tmp[0],
4213 seq_printf(m, "\r\n %-35s = %s/ %s/ %s/ %d",
4214 "AntDiv/BtCtrlLPS/LPRA/PsFail",
4215 ((board_info->ant_div_cfg) ? "On" : "Off"),
4216 ((coex_sta->force_lps_ctrl) ? "On" : "Off"),
4217 ((coex_dm->cur_low_penalty_ra) ? "On" : "Off"),
4218 coex_sta->cnt_set_ps_state_fail);
4220 u32tmp[0] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
4221 lte_coex_on = ((u32tmp[0] & BIT(7)) >> 7) ? true : false;
4224 u32tmp[0] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
4226 u32tmp[1] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
4229 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x",
4230 "LTE Coex Table W_L/B_L", u32tmp[0] & 0xffff,
4231 u32tmp[1] & 0xffff);
4233 u32tmp[0] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
4235 u32tmp[1] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
4237 u32tmp[2] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
4239 u32tmp[3] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist,
4242 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4243 "LTE Break Table W_L/B_L/L_W/L_B",
4244 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff,
4245 u32tmp[2] & 0xffff, u32tmp[3] & 0xffff);
4249 seq_printf(m, "\r\n %-35s", "============[Hw setting]============");
4251 u32tmp[0] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
4252 u32tmp[1] = halbtc8822b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
4253 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x73);
4255 seq_printf(m, "\r\n %-35s = %s/ %s", "LTE Coex/Path Owner",
4256 ((lte_coex_on) ? "On" : "Off"),
4257 ((u8tmp[0] & BIT(2)) ? "WL" : "BT"));
4260 seq_printf(m, "\r\n %-35s = %d/ %d/ %d/ %d",
4261 "LTE 3Wire/OPMode/UART/UARTMode",
4262 (int)((u32tmp[0] & BIT(6)) >> 6),
4263 (int)((u32tmp[0] & (BIT(5) | BIT(4))) >> 4),
4264 (int)((u32tmp[0] & BIT(3)) >> 3),
4265 (int)(u32tmp[0] & (BIT(2) | BIT(1) | BIT(0))));
4267 seq_printf(m, "\r\n %-35s = %d/ %d", "LTE_Busy/UART_Busy",
4268 (int)((u32tmp[1] & BIT(1)) >> 1),
4269 (int)(u32tmp[1] & BIT(0)));
4271 seq_printf(m, "\r\n %-35s = %s (BB:%s)/ %s (BB:%s)/ %s %d",
4272 "GNT_WL_Ctrl/GNT_BT_Ctrl/Dbg",
4273 ((u32tmp[0] & BIT(12)) ? "SW" : "HW"),
4274 ((u32tmp[0] & BIT(8)) ? "SW" : "HW"),
4275 ((u32tmp[0] & BIT(14)) ? "SW" : "HW"),
4276 ((u32tmp[0] & BIT(10)) ? "SW" : "HW"),
4277 ((u8tmp[0] & BIT(3)) ? "On" : "Off"),
4278 coex_sta->gnt_error_cnt);
4280 seq_printf(m, "\r\n %-35s = %d/ %d", "GNT_WL/GNT_BT",
4281 (int)((u32tmp[1] & BIT(2)) >> 2),
4282 (int)((u32tmp[1] & BIT(3)) >> 3));
4284 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb0);
4285 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
4286 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xcba);
4288 seq_printf(m, "\r\n %-35s = 0x%04x/ 0x%04x/ 0x%02x %s",
4289 "0xcb0/0xcb4/0xcb8[23:16]", u32tmp[0], u32tmp[1], u8tmp[0],
4290 ((u8tmp[0] & 0x1) == 0x1 ? "(BTG)" : "(WL_A+G)"));
4292 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
4293 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
4294 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x4c6);
4295 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
4297 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4298 "4c[24:23]/64[0]/4c6[4]/40[5]",
4299 (int)((u32tmp[0] & (BIT(24) | BIT(23))) >> 23),
4300 u8tmp[2] & 0x1, (int)((u8tmp[0] & BIT(4)) >> 4),
4301 (int)((u8tmp[1] & BIT(5)) >> 5));
4303 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
4304 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
4305 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x953);
4306 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0xc50);
4308 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ %s/ 0x%x",
4309 "0x550/0x522/4-RxAGC/0xc50", u32tmp[0], u8tmp[0],
4310 (u8tmp[1] & 0x2) ? "On" : "Off", u8tmp[2]);
4312 fa_ofdm = btcoexist->btc_phydm_query_phy_counter(btcoexist,
4313 "PHYDM_INFO_FA_OFDM");
4314 fa_cck = btcoexist->btc_phydm_query_phy_counter(btcoexist,
4315 "PHYDM_INFO_FA_CCK");
4316 cca_ofdm = btcoexist->btc_phydm_query_phy_counter(
4317 btcoexist, "PHYDM_INFO_CCA_OFDM");
4318 cca_cck = btcoexist->btc_phydm_query_phy_counter(btcoexist,
4319 "PHYDM_INFO_CCA_CCK");
4321 seq_printf(m, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4322 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA", cca_cck, fa_cck, cca_ofdm,
4325 seq_printf(m, "\r\n %-35s = %d/ %d/ %d/ %d", "CRC_OK CCK/11g/11n/11ac",
4326 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
4327 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht);
4329 seq_printf(m, "\r\n %-35s = %d/ %d/ %d/ %d", "CRC_Err CCK/11g/11n/11ac",
4330 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
4331 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
4333 seq_printf(m, "\r\n %-35s = %s/ %s/ %s/ %d",
4334 "WlHiPri/ Locking/ Locked/ Noisy",
4335 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
4336 (coex_sta->cck_lock ? "Yes" : "No"),
4337 (coex_sta->cck_ever_lock ? "Yes" : "No"),
4338 coex_sta->wl_noisy_level);
4340 seq_printf(m, "\r\n %-35s = %d/ %d", "0x770(Hi-pri rx/tx)",
4341 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
4343 seq_printf(m, "\r\n %-35s = %d/ %d %s", "0x774(Lo-pri rx/tx)",
4344 coex_sta->low_priority_rx, coex_sta->low_priority_tx,
4345 (bt_link_info->slave_role ?
4347 (coex_sta->is_tdma_btautoslot_hang ?
4348 "(auto-slot hang!!)" :
4351 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
4354 void ex_btc8822b1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
4356 struct rtl_priv *rtlpriv = btcoexist->adapter;
4358 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4361 if (type == BTC_IPS_ENTER) {
4362 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4363 "[BTCoex], IPS ENTER notify\n");
4364 coex_sta->under_ips = true;
4366 /* Write WL "Active" in Score-board for LPS off */
4367 halbtc8822b1ant_post_state_to_bt(
4368 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, false);
4370 halbtc8822b1ant_post_state_to_bt(
4371 btcoexist, BT_8822B_1ANT_SCOREBOARD_ONOFF, false);
4373 halbtc8822b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
4375 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4377 BT_8822B_1ANT_PHASE_WLAN_OFF);
4379 halbtc8822b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
4380 } else if (type == BTC_IPS_LEAVE) {
4381 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4382 "[BTCoex], IPS LEAVE notify\n");
4383 halbtc8822b1ant_post_state_to_bt(
4384 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, true);
4386 halbtc8822b1ant_post_state_to_bt(
4387 btcoexist, BT_8822B_1ANT_SCOREBOARD_ONOFF, true);
4389 /*leave IPS : run ini hw config (exclude wifi only)*/
4390 halbtc8822b1ant_init_hw_config(btcoexist, false, false);
4392 halbtc8822b1ant_init_coex_dm(btcoexist);
4393 /*leave IPS : Query bt info*/
4394 halbtc8822b1ant_query_bt_info(btcoexist);
4396 coex_sta->under_ips = false;
4400 void ex_btc8822b1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
4402 struct rtl_priv *rtlpriv = btcoexist->adapter;
4403 static bool pre_force_lps_on;
4405 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4408 if (type == BTC_LPS_ENABLE) {
4409 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4410 "[BTCoex], LPS ENABLE notify\n");
4411 coex_sta->under_lps = true;
4413 if (coex_sta->force_lps_ctrl) { /* LPS No-32K */
4414 /* Write WL "Active" in Score-board for PS-TDMA */
4415 pre_force_lps_on = true;
4416 halbtc8822b1ant_post_state_to_bt(
4417 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE,
4420 /* LPS-32K, need check if this h2c 0x71 can work??
4423 /* Write WL "Non-Active" in Score-board for Native-PS */
4424 pre_force_lps_on = false;
4425 halbtc8822b1ant_post_state_to_bt(
4426 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE,
4429 } else if (type == BTC_LPS_DISABLE) {
4430 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4431 "[BTCoex], LPS DISABLE notify\n");
4432 coex_sta->under_lps = false;
4434 /* Write WL "Active" in Score-board for LPS off */
4435 halbtc8822b1ant_post_state_to_bt(
4436 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, true);
4438 if ((!pre_force_lps_on) && (!coex_sta->force_lps_ctrl))
4439 halbtc8822b1ant_query_bt_info(btcoexist);
4443 void ex_btc8822b1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
4445 struct rtl_priv *rtlpriv = btcoexist->adapter;
4446 bool wifi_connected = false;
4447 bool wifi_under_5g = false;
4449 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4452 coex_sta->freeze_coexrun_by_btinfo = false;
4454 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4458 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4459 "[BTCoex], ********** WL connected before SCAN\n");
4462 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4463 "[BTCoex], ********** WL is not connected before SCAN\n");
4465 halbtc8822b1ant_query_bt_info(btcoexist);
4468 if (type == BTC_SCAN_START) {
4469 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G,
4473 if (wifi_under_5g) {
4475 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4476 "[BTCoex], ********** (scan_notify_5g_scan_start) **********\n");
4477 halbtc8822b1ant_action_wifi_under5g(btcoexist);
4482 coex_sta->wifi_is_high_pri_task = true;
4485 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4486 "[BTCoex], ********** (scan_notify_2g_scan_start) **********\n");
4488 if (!wifi_connected) { /* non-connected scan */
4490 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4491 "[BTCoex], ********** wifi is not connected scan **********\n");
4492 halbtc8822b1ant_action_wifi_not_connected_scan(
4494 } else { /* wifi is connected */
4496 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4497 "[BTCoex], ********** wifi is connected scan **********\n");
4498 halbtc8822b1ant_action_wifi_connected_scan(btcoexist);
4504 if (type == BTC_SCAN_START_2G) {
4505 coex_sta->wifi_is_high_pri_task = true;
4508 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4509 "[BTCoex], ********** (scan_notify_2g_sacn_start_for_switch_band_used) **********\n");
4511 if (!wifi_connected) { /* non-connected scan */
4513 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4514 "[BTCoex], ********** wifi is not connected **********\n");
4516 halbtc8822b1ant_action_wifi_not_connected_scan(
4518 } else { /* wifi is connected */
4520 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4521 "[BTCoex], ********** wifi is connected **********\n");
4522 halbtc8822b1ant_action_wifi_connected_scan(btcoexist);
4525 coex_sta->wifi_is_high_pri_task = false;
4527 /* 2.4G 5 WL scan finish, then get and update sacn ap numbers */
4529 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4530 &coex_sta->scan_ap_num);
4533 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4534 "[BTCoex], ********** (scan_finish_notify) **********\n");
4536 if (!wifi_connected) { /* non-connected scan */
4537 halbtc8822b1ant_action_wifi_not_connected(btcoexist);
4540 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4541 "[BTCoex], ********** scan_finish_notify wifi is connected **********\n");
4542 halbtc8822b1ant_action_wifi_connected(btcoexist);
4547 void ex_btc8822b1ant_scan_notify_without_bt(struct btc_coexist *btcoexist,
4550 bool wifi_under_5g = false;
4552 if (type == BTC_SCAN_START) {
4553 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G,
4556 if (wifi_under_5g) {
4557 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd,
4563 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd, 0x3, 2);
4566 if (type == BTC_SCAN_START_2G)
4567 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd, 0x3, 2);
4570 void ex_btc8822b1ant_switchband_notify(struct btc_coexist *btcoexist, u8 type)
4572 struct rtl_priv *rtlpriv = btcoexist->adapter;
4574 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4575 "[BTCoex], ********** (switchband_notify) **********\n");
4577 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4580 coex_sta->switch_band_notify_to = type;
4581 /*2.4g 4.*/ /*5 g 2*/
4582 if (type == BTC_SWITCH_TO_5G) {
4584 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4585 "[BTCoex], ********** (switchband_notify BTC_SWITCH_TO_5G) **********\n");
4587 halbtc8822b1ant_action_wifi_under5g(btcoexist);
4589 } else if (type == BTC_SWITCH_TO_24G_NOFORSCAN) {
4591 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4592 "[BTCoex], ********** (switchband_notify BTC_SWITCH_TO_2G (no for scan)) **********\n");
4594 halbtc8822b1ant_run_coexist_mechanism(btcoexist);
4599 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4600 "[BTCoex], ********** (switchband_notify BTC_SWITCH_TO_2G) **********\n");
4602 ex_btc8822b1ant_scan_notify(btcoexist, BTC_SCAN_START_2G);
4604 coex_sta->switch_band_notify_to = BTC_NOT_SWITCH;
4607 void ex_btc8822b1ant_switchband_notify_without_bt(struct btc_coexist *btcoexist,
4610 bool wifi_under_5g = false;
4612 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
4614 if (type == BTC_SWITCH_TO_5G) {
4615 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd, 0x3, 1);
4617 } else if (type == BTC_SWITCH_TO_24G_NOFORSCAN) {
4620 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd,
4624 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcbd,
4627 ex_btc8822b1ant_scan_notify_without_bt(btcoexist,
4632 void ex_btc8822b1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
4634 struct rtl_priv *rtlpriv = btcoexist->adapter;
4635 bool wifi_connected = false;
4637 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4638 "[BTCoex], ********** (connect notify) **********\n");
4640 halbtc8822b1ant_post_state_to_bt(btcoexist,
4641 BT_8822B_1ANT_SCOREBOARD_SCAN, true);
4643 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4646 if ((type == BTC_ASSOCIATE_5G_START) ||
4647 (type == BTC_ASSOCIATE_5G_FINISH)) {
4648 if (type == BTC_ASSOCIATE_5G_START) {
4650 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4651 "[BTCoex], ********** (5G associate start notify) **********\n");
4653 halbtc8822b1ant_action_wifi_under5g(btcoexist);
4655 } else if (type == BTC_ASSOCIATE_5G_FINISH) {
4657 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4658 "[BTCoex], ********** (5G associate finish notify) **********\n");
4664 if (type == BTC_ASSOCIATE_START) {
4665 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4666 "[BTCoex], 2G CONNECT START notify\n");
4668 coex_sta->wifi_is_high_pri_task = true;
4670 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4672 BT_8822B_1ANT_PHASE_2G_RUNTIME);
4674 coex_dm->arp_cnt = 0;
4676 halbtc8822b1ant_action_wifi_not_connected_asso_auth(btcoexist);
4678 coex_sta->freeze_coexrun_by_btinfo = true;
4681 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4682 "[BTCoex], 2G CONNECT Finish notify\n");
4683 coex_sta->wifi_is_high_pri_task = false;
4684 coex_sta->freeze_coexrun_by_btinfo = false;
4686 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4689 if (!wifi_connected) /* non-connected scan */
4690 halbtc8822b1ant_action_wifi_not_connected(btcoexist);
4692 halbtc8822b1ant_action_wifi_connected(btcoexist);
4696 void ex_btc8822b1ant_media_status_notify(struct btc_coexist *btcoexist, u8 type)
4698 struct rtl_priv *rtlpriv = btcoexist->adapter;
4699 bool wifi_under_b_mode = false;
4700 bool wifi_under_5g = false;
4702 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4705 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
4707 if (type == BTC_MEDIA_CONNECT) {
4708 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4709 "[BTCoex], 2g media connect notify");
4711 halbtc8822b1ant_post_state_to_bt(
4712 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, true);
4714 if (wifi_under_5g) {
4715 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4716 "[BTCoex], 5g media notify\n");
4718 halbtc8822b1ant_action_wifi_under5g(btcoexist);
4721 /* Force antenna setup for no scan result issue */
4722 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4724 BT_8822B_1ANT_PHASE_2G_RUNTIME);
4726 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
4727 &wifi_under_b_mode);
4729 /* Set CCK Tx/Rx high Pri except 11b mode */
4730 if (wifi_under_b_mode) {
4732 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4733 "[BTCoex], ********** (media status notity under b mode) **********\n");
4734 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
4736 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
4740 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4741 "[BTCoex], ********** (media status notity not under b mode) **********\n");
4742 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
4744 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
4748 coex_dm->backup_arfr_cnt1 =
4749 btcoexist->btc_read_4byte(btcoexist, 0x430);
4750 coex_dm->backup_arfr_cnt2 =
4751 btcoexist->btc_read_4byte(btcoexist, 0x434);
4752 coex_dm->backup_retry_limit =
4753 btcoexist->btc_read_2byte(btcoexist, 0x42a);
4754 coex_dm->backup_ampdu_max_time =
4755 btcoexist->btc_read_1byte(btcoexist, 0x456);
4757 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4758 "[BTCoex], 2g media disconnect notify\n");
4759 coex_dm->arp_cnt = 0;
4761 halbtc8822b1ant_post_state_to_bt(
4762 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, false);
4764 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
4765 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
4767 coex_sta->cck_ever_lock = false;
4770 halbtc8822b1ant_update_wifi_ch_info(btcoexist, type);
4773 void ex_btc8822b1ant_specific_packet_notify(struct btc_coexist *btcoexist,
4776 struct rtl_priv *rtlpriv = btcoexist->adapter;
4777 bool under_4way = false, wifi_under_5g = false;
4779 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4782 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
4783 if (wifi_under_5g) {
4784 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4785 "[BTCoex], 5g special packet notify\n");
4787 halbtc8822b1ant_action_wifi_under5g(btcoexist);
4791 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
4795 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4796 "[BTCoex], specific Packet ---- under_4way!!\n");
4798 coex_sta->wifi_is_high_pri_task = true;
4799 coex_sta->specific_pkt_period_cnt = 2;
4800 } else if (type == BTC_PACKET_ARP) {
4803 if (coex_sta->wifi_is_high_pri_task) {
4805 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4806 "[BTCoex], specific Packet ARP notify -cnt = %d\n",
4812 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4813 "[BTCoex], specific Packet DHCP or EAPOL notify [Type = %d]\n",
4816 coex_sta->wifi_is_high_pri_task = true;
4817 coex_sta->specific_pkt_period_cnt = 2;
4820 if (coex_sta->wifi_is_high_pri_task)
4821 halbtc8822b1ant_action_wifi_connected_specific_packet(
4825 void ex_btc8822b1ant_bt_info_notify(struct btc_coexist *btcoexist, u8 *tmp_buf,
4828 struct rtl_priv *rtlpriv = btcoexist->adapter;
4829 u8 i, rsp_source = 0;
4830 bool wifi_connected = false;
4831 bool wifi_scan = false, wifi_link = false, wifi_roam = false,
4833 static bool is_scoreboard_scan;
4835 if (psd_scan->is_ant_det_running) {
4837 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4838 "[BTCoex], bt_info_notify return for AntDet is running\n");
4842 rsp_source = tmp_buf[0] & 0xf;
4843 if (rsp_source >= BT_INFO_SRC_8822B_1ANT_MAX)
4844 rsp_source = BT_INFO_SRC_8822B_1ANT_WIFI_FW;
4845 coex_sta->bt_info_c2h_cnt[rsp_source]++;
4847 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4848 "[BTCoex], Bt_info[%d], len=%d, data=[", rsp_source, length);
4850 for (i = 0; i < length; i++) {
4851 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
4853 if (i == length - 1) {
4855 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4856 "0x%02x]\n", tmp_buf[i]);
4859 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "0x%02x, ",
4864 coex_sta->bt_info = coex_sta->bt_info_c2h[rsp_source][1];
4865 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4866 coex_sta->bt_info_ext2 = coex_sta->bt_info_c2h[rsp_source][5];
4868 if (rsp_source != BT_INFO_SRC_8822B_1ANT_WIFI_FW) {
4869 /* if 0xff, it means BT is under WHCK test */
4870 coex_sta->bt_whck_test =
4871 ((coex_sta->bt_info == 0xff) ? true : false);
4873 coex_sta->bt_create_connection =
4874 ((coex_sta->bt_info_c2h[rsp_source][2] & 0x80) ? true :
4877 /* unit: %, value-100 to translate to unit: dBm */
4879 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4881 coex_sta->c2h_bt_remote_name_req =
4882 ((coex_sta->bt_info_c2h[rsp_source][2] & 0x20) ? true :
4885 coex_sta->is_A2DP_3M =
4886 ((coex_sta->bt_info_c2h[rsp_source][2] & 0x10) ? true :
4889 coex_sta->acl_busy =
4890 ((coex_sta->bt_info_c2h[rsp_source][1] & 0x9) ? true :
4893 coex_sta->voice_over_HOGP =
4894 ((coex_sta->bt_info_ext & 0x10) ? true : false);
4896 coex_sta->c2h_bt_inquiry_page =
4897 ((coex_sta->bt_info & BT_INFO_8822B_1ANT_B_INQ_PAGE) ?
4901 coex_sta->a2dp_bit_pool =
4902 (((coex_sta->bt_info_c2h[rsp_source][1] & 0x49) ==
4904 (coex_sta->bt_info_c2h[rsp_source][6] & 0x7f) :
4907 coex_sta->is_bt_a2dp_sink =
4908 (coex_sta->bt_info_c2h[rsp_source][6] & 0x80) ? true :
4911 coex_sta->bt_retry_cnt =
4912 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
4914 coex_sta->is_autoslot = coex_sta->bt_info_ext2 & 0x8;
4916 coex_sta->forbidden_slot = coex_sta->bt_info_ext2 & 0x7;
4918 coex_sta->hid_busy_num = (coex_sta->bt_info_ext2 & 0x30) >> 4;
4920 coex_sta->hid_pair_cnt = (coex_sta->bt_info_ext2 & 0xc0) >> 6;
4921 if (coex_sta->bt_retry_cnt >= 1)
4922 coex_sta->pop_event_cnt++;
4924 if (coex_sta->c2h_bt_remote_name_req)
4925 coex_sta->cnt_remote_name_req++;
4927 if (coex_sta->bt_info_ext & BIT(1))
4928 coex_sta->cnt_reinit++;
4930 if (coex_sta->bt_info_ext & BIT(2)) {
4931 coex_sta->cnt_setup_link++;
4932 coex_sta->is_setup_link = true;
4933 coex_sta->bt_relink_downcount = 2;
4934 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4935 "[BTCoex], Re-Link start in BT info!!\n");
4937 coex_sta->is_setup_link = false;
4938 coex_sta->bt_relink_downcount = 0;
4939 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4940 "[BTCoex], Re-Link stop in BT info!!\n");
4943 if (coex_sta->bt_info_ext & BIT(3))
4944 coex_sta->cnt_ign_wlan_act++;
4946 if (coex_sta->bt_info_ext & BIT(6))
4947 coex_sta->cnt_role_switch++;
4949 if (coex_sta->bt_info_ext & BIT(7))
4950 coex_sta->is_bt_multi_link = true;
4952 coex_sta->is_bt_multi_link = false;
4954 if (coex_sta->bt_create_connection) {
4955 coex_sta->cnt_page++;
4957 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
4960 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN,
4962 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK,
4964 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM,
4967 if ((wifi_link) || (wifi_roam) || (wifi_scan) ||
4968 (coex_sta->wifi_is_high_pri_task) || (wifi_busy)) {
4969 is_scoreboard_scan = true;
4970 halbtc8822b1ant_post_state_to_bt(
4972 BT_8822B_1ANT_SCOREBOARD_SCAN, true);
4975 halbtc8822b1ant_post_state_to_bt(
4977 BT_8822B_1ANT_SCOREBOARD_SCAN, false);
4980 if (is_scoreboard_scan) {
4981 halbtc8822b1ant_post_state_to_bt(
4983 BT_8822B_1ANT_SCOREBOARD_SCAN, false);
4984 is_scoreboard_scan = false;
4988 /* Here we need to resend some wifi info to BT */
4989 /* because bt is reset and loss of the info. */
4991 if ((!btcoexist->manual_control) &&
4992 (!btcoexist->stop_coex_dm)) {
4993 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4997 if ((coex_sta->bt_info_ext & BIT(1))) {
4999 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5000 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
5002 halbtc8822b1ant_update_wifi_ch_info(
5003 btcoexist, BTC_MEDIA_CONNECT);
5005 halbtc8822b1ant_update_wifi_ch_info(
5007 BTC_MEDIA_DISCONNECT);
5010 /* If Ignore_WLanAct && not SetUp_Link */
5011 if ((coex_sta->bt_info_ext & BIT(3)) &&
5012 (!(coex_sta->bt_info_ext & BIT(2)))) {
5014 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5015 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
5016 halbtc8822b1ant_ignore_wlan_act(
5017 btcoexist, FORCE_EXEC, false);
5022 if ((coex_sta->bt_info_ext & BIT(5))) {
5024 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5025 "[BTCoex], BT ext info bit4 check, query BLE Scan type!!\n");
5026 coex_sta->bt_ble_scan_type =
5027 btcoexist->btc_get_ble_scan_type_from_bt(btcoexist);
5029 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1)
5030 coex_sta->bt_ble_scan_para[0] =
5031 btcoexist->btc_get_ble_scan_para_from_bt(
5033 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2)
5034 coex_sta->bt_ble_scan_para[1] =
5035 btcoexist->btc_get_ble_scan_para_from_bt(
5037 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4)
5038 coex_sta->bt_ble_scan_para[2] =
5039 btcoexist->btc_get_ble_scan_para_from_bt(
5043 halbtc8822b1ant_update_bt_link_info(btcoexist);
5045 halbtc8822b1ant_run_coexist_mechanism(btcoexist);
5048 void ex_btc8822b1ant_rf_status_notify(struct btc_coexist *btcoexist, u8 type)
5050 struct rtl_priv *rtlpriv = btcoexist->adapter;
5052 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5053 "[BTCoex], RF Status notify\n");
5055 if (type == BTC_RF_ON) {
5056 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5057 "[BTCoex], RF is turned ON!!\n");
5058 btcoexist->stop_coex_dm = false;
5060 halbtc8822b1ant_post_state_to_bt(
5061 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, true);
5062 halbtc8822b1ant_post_state_to_bt(
5063 btcoexist, BT_8822B_1ANT_SCOREBOARD_ONOFF, true);
5065 } else if (type == BTC_RF_OFF) {
5066 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5067 "[BTCoex], RF is turned OFF!!\n");
5069 halbtc8822b1ant_post_state_to_bt(
5070 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, false);
5071 halbtc8822b1ant_post_state_to_bt(
5072 btcoexist, BT_8822B_1ANT_SCOREBOARD_ONOFF, false);
5073 halbtc8822b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
5075 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
5077 BT_8822B_1ANT_PHASE_WLAN_OFF);
5078 /* for test : s3 bt disppear , fail rate 1/600*/
5080 halbtc8822b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
5082 btcoexist->stop_coex_dm = true;
5086 void ex_btc8822b1ant_halt_notify(struct btc_coexist *btcoexist)
5088 struct rtl_priv *rtlpriv = btcoexist->adapter;
5090 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n");
5092 halbtc8822b1ant_post_state_to_bt(
5093 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE, false);
5094 halbtc8822b1ant_post_state_to_bt(btcoexist,
5095 BT_8822B_1ANT_SCOREBOARD_ONOFF, false);
5097 halbtc8822b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
5099 halbtc8822b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, FORCE_EXEC,
5100 BT_8822B_1ANT_PHASE_WLAN_OFF);
5101 /* for test : s3 bt disppear , fail rate 1/600*/
5103 halbtc8822b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
5105 ex_btc8822b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
5106 btcoexist->stop_coex_dm = true;
5109 void ex_btc8822b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
5111 struct rtl_priv *rtlpriv = btcoexist->adapter;
5112 bool wifi_under_5g = false;
5114 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
5116 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
5118 if ((pnp_state == BTC_WIFI_PNP_SLEEP) ||
5119 (pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT)) {
5120 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5121 "[BTCoex], Pnp notify to SLEEP\n");
5123 halbtc8822b1ant_post_state_to_bt(
5124 btcoexist, BT_8822B_1ANT_SCOREBOARD_ACTIVE |
5125 BT_8822B_1ANT_SCOREBOARD_ONOFF |
5126 BT_8822B_1ANT_SCOREBOARD_SCAN |
5127 BT_8822B_1ANT_SCOREBOARD_UNDERTEST,
5130 if (pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT) {
5132 halbtc8822b1ant_set_ant_path(
5133 btcoexist, BTC_ANT_PATH_AUTO,
5135 BT_8822B_1ANT_PHASE_5G_RUNTIME);
5137 halbtc8822b1ant_set_ant_path(
5138 btcoexist, BTC_ANT_PATH_AUTO,
5140 BT_8822B_1ANT_PHASE_2G_RUNTIME);
5142 halbtc8822b1ant_set_ant_path(
5143 btcoexist, BTC_ANT_PATH_AUTO, FORCE_EXEC,
5144 BT_8822B_1ANT_PHASE_WLAN_OFF);
5147 btcoexist->stop_coex_dm = true;
5148 } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
5149 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5150 "[BTCoex], Pnp notify to WAKE UP\n");
5151 btcoexist->stop_coex_dm = false;
5155 void ex_btc8822b1ant_coex_dm_reset(struct btc_coexist *btcoexist)
5157 struct rtl_priv *rtlpriv = btcoexist->adapter;
5159 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5160 "[BTCoex], *****************Coex DM Reset*****************\n");
5162 halbtc8822b1ant_init_hw_config(btcoexist, false, false);
5163 halbtc8822b1ant_init_coex_dm(btcoexist);
5166 void ex_btc8822b1ant_periodical(struct btc_coexist *btcoexist)
5168 struct rtl_priv *rtlpriv = btcoexist->adapter;
5169 bool bt_relink_finish = false;
5172 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5173 "[BTCoex], ==========================Periodical===========================\n");
5175 if (!btcoexist->auto_report_1ant)
5176 halbtc8822b1ant_query_bt_info(btcoexist);
5178 halbtc8822b1ant_monitor_bt_ctr(btcoexist);
5179 halbtc8822b1ant_monitor_wifi_ctr(btcoexist);
5181 halbtc8822b1ant_monitor_bt_enable_disable(btcoexist);
5183 if (coex_sta->bt_relink_downcount != 0) {
5184 coex_sta->bt_relink_downcount--;
5186 if (coex_sta->bt_relink_downcount == 0) {
5187 coex_sta->is_setup_link = false;
5188 bt_relink_finish = true;
5192 /* for 4-way, DHCP, EAPOL packet */
5193 if (coex_sta->specific_pkt_period_cnt > 0) {
5194 coex_sta->specific_pkt_period_cnt--;
5196 if ((coex_sta->specific_pkt_period_cnt == 0) &&
5197 (coex_sta->wifi_is_high_pri_task))
5198 coex_sta->wifi_is_high_pri_task = false;
5201 rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
5202 "[BTCoex], ***************** Hi-Pri Task = %s*****************\n",
5203 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"));
5206 if (halbtc8822b1ant_is_wifi_status_changed(btcoexist) ||
5207 (bt_relink_finish) || (coex_sta->is_set_ps_state_fail))
5208 halbtc8822b1ant_run_coexist_mechanism(btcoexist);
5211 void ex_btc8822b1ant_antenna_detection(struct btc_coexist *btcoexist,
5212 u32 cent_freq, u32 offset, u32 span,
5217 void ex_btc8822b1ant_antenna_isolation(struct btc_coexist *btcoexist,
5218 u32 cent_freq, u32 offset, u32 span,
5223 void ex_btc8822b1ant_psd_scan(struct btc_coexist *btcoexist, u32 cent_freq,
5224 u32 offset, u32 span, u32 seconds)
5228 void ex_btc8822b1ant_display_ant_detection(struct btc_coexist *btcoexist) {}
5230 void ex_btc8822b1ant_dbg_control(struct btc_coexist *btcoexist, u8 op_code,
5231 u8 op_len, u8 *pdata)