1 /* ************************************************************
4 * This file is for RTL8723D Co-exist mechanism
7 * 2012/11/15 Cosa first check in.
9 * ************************************************************ */
11 /* ************************************************************
13 * ************************************************************ */
14 #include "Mp_Precomp.h"
16 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
18 #if (RTL8723D_SUPPORT == 1)
19 /* ************************************************************
20 * Global variables, these are static variables
21 * ************************************************************ */
22 static u8 *trace_buf = &gl_btc_trace_buf[0];
23 static struct coex_dm_8723d_2ant glcoex_dm_8723d_2ant;
24 static struct coex_dm_8723d_2ant *coex_dm = &glcoex_dm_8723d_2ant;
25 static struct coex_sta_8723d_2ant glcoex_sta_8723d_2ant;
26 static struct coex_sta_8723d_2ant *coex_sta = &glcoex_sta_8723d_2ant;
27 static struct psdscan_sta_8723d_2ant gl_psd_scan_8723d_2ant;
28 static struct psdscan_sta_8723d_2ant *psd_scan = &gl_psd_scan_8723d_2ant;
30 const char *const glbt_info_src_8723d_2ant[] = {
33 "BT Info[bt auto report]",
35 /* ************************************************************
36 * BtCoex Version Format:
37 * 1. date : glcoex_ver_date_XXXXX_1ant
38 * 2. WifiCoexVersion : glcoex_ver_XXXX_1ant
39 * 3. BtCoexVersion : glcoex_ver_btdesired_XXXXX_1ant
40 * 4. others : glcoex_ver_XXXXXX_XXXXX_1ant
42 * Variable should be indicated IC and Antenna numbers !!!
43 * Please strictly follow this order and naming style !!!
45 * ************************************************************ */
46 u32 glcoex_ver_date_8723d_2ant = 20161208;
47 u32 glcoex_ver_8723d_2ant = 0x12;
48 u32 glcoex_ver_btdesired_8723d_2ant = 0x10;
51 /* ************************************************************
52 * local function proto type if needed
53 * ************************************************************
54 * ************************************************************
55 * local function start with halbtc8723d2ant_
56 * ************************************************************ */
57 u8 halbtc8723d2ant_bt_rssi_state(u8 *ppre_bt_rssi_state, u8 level_num,
58 u8 rssi_thresh, u8 rssi_thresh1)
61 u8 bt_rssi_state = *ppre_bt_rssi_state;
63 bt_rssi = coex_sta->bt_rssi;
66 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
67 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
68 if (bt_rssi >= (rssi_thresh +
69 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
70 bt_rssi_state = BTC_RSSI_STATE_HIGH;
72 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
74 if (bt_rssi < rssi_thresh)
75 bt_rssi_state = BTC_RSSI_STATE_LOW;
77 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
79 } else if (level_num == 3) {
80 if (rssi_thresh > rssi_thresh1) {
81 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
82 "[BTCoex], BT Rssi thresh error!!\n");
84 return *ppre_bt_rssi_state;
87 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
88 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
89 if (bt_rssi >= (rssi_thresh +
90 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
91 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
93 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
94 } else if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
95 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
96 if (bt_rssi >= (rssi_thresh1 +
97 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
98 bt_rssi_state = BTC_RSSI_STATE_HIGH;
99 else if (bt_rssi < rssi_thresh)
100 bt_rssi_state = BTC_RSSI_STATE_LOW;
102 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
104 if (bt_rssi < rssi_thresh1)
105 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
107 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
111 *ppre_bt_rssi_state = bt_rssi_state;
113 return bt_rssi_state;
116 u8 halbtc8723d2ant_wifi_rssi_state(IN struct btc_coexist *btcoexist,
117 IN u8 *pprewifi_rssi_state, IN u8 level_num, IN u8 rssi_thresh,
121 u8 wifi_rssi_state = *pprewifi_rssi_state;
123 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
125 if (level_num == 2) {
126 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
127 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
128 if (wifi_rssi >= (rssi_thresh +
129 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
130 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
132 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
134 if (wifi_rssi < rssi_thresh)
135 wifi_rssi_state = BTC_RSSI_STATE_LOW;
137 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
139 } else if (level_num == 3) {
140 if (rssi_thresh > rssi_thresh1) {
141 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
142 "[BTCoex], wifi RSSI thresh error!!\n");
143 BTC_TRACE(trace_buf);
144 return *pprewifi_rssi_state;
147 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
148 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
149 if (wifi_rssi >= (rssi_thresh +
150 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
151 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
153 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
154 } else if ((*pprewifi_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
155 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
156 if (wifi_rssi >= (rssi_thresh1 +
157 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
158 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
159 else if (wifi_rssi < rssi_thresh)
160 wifi_rssi_state = BTC_RSSI_STATE_LOW;
162 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
164 if (wifi_rssi < rssi_thresh1)
165 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
167 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
171 *pprewifi_rssi_state = wifi_rssi_state;
173 return wifi_rssi_state;
176 void halbtc8723d2ant_coex_switch_threshold(IN struct btc_coexist *btcoexist,
177 IN u8 isolation_measuared)
179 s8 interference_wl_tx = 0, interference_bt_tx = 0;
182 interference_wl_tx = BT_8723D_2ANT_WIFI_MAX_TX_POWER -
184 interference_bt_tx = BT_8723D_2ANT_BT_MAX_TX_POWER -
189 coex_sta->wifi_coex_thres = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1;
190 coex_sta->wifi_coex_thres2 = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES2;
192 coex_sta->bt_coex_thres = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1;
193 coex_sta->bt_coex_thres2 = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES2;
197 coex_sta->wifi_coex_thres = interference_wl_tx + BT_8723D_2ANT_WIFI_SIR_THRES1;
198 coex_sta->wifi_coex_thres2 = interference_wl_tx + BT_8723D_2ANT_WIFI_SIR_THRES2;
200 coex_sta->bt_coex_thres = interference_bt_tx + BT_8723D_2ANT_BT_SIR_THRES1;
201 coex_sta->bt_coex_thres2 = interference_bt_tx + BT_8723D_2ANT_BT_SIR_THRES2;
209 if ( BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1 < (isolation_measuared -
210 BT_8723D_2ANT_DEFAULT_ISOLATION) )
211 coex_sta->wifi_coex_thres = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1;
213 coex_sta->wifi_coex_thres = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1 - (isolation_measuared -
214 BT_8723D_2ANT_DEFAULT_ISOLATION);
216 if ( BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1 < (isolation_measuared -
217 BT_8723D_2ANT_DEFAULT_ISOLATION) )
218 coex_sta->bt_coex_thres = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1;
220 coex_sta->bt_coex_thres = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1 - (isolation_measuared -
221 BT_8723D_2ANT_DEFAULT_ISOLATION);
227 void halbtc8723d2ant_limited_rx(IN struct btc_coexist *btcoexist,
228 IN boolean force_exec, IN boolean rej_ap_agg_pkt,
229 IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
231 boolean reject_rx_agg = rej_ap_agg_pkt;
232 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
233 u8 rx_agg_size = agg_buf_size;
235 /* ============================================ */
236 /* Rx Aggregation related setting */
237 /* ============================================ */
238 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
240 /* decide BT control aggregation buf size or not */
241 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
242 &bt_ctrl_rx_agg_size);
243 /* aggregation buf size, only work when BT control Rx aggregation size. */
244 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
245 /* real update aggregation setting */
246 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
249 void halbtc8723d2ant_query_bt_info(IN struct btc_coexist *btcoexist)
251 u8 h2c_parameter[1] = {0};
254 h2c_parameter[0] |= BIT(0); /* trigger */
256 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
259 void halbtc8723d2ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
261 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
262 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
263 static u8 num_of_bt_counter_chk = 0, cnt_slave = 0, cnt_overhead = 0,
264 cnt_autoslot_hang = 0;
266 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
271 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
272 reg_hp_tx = u32tmp & MASKLWORD;
273 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
275 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
276 reg_lp_tx = u32tmp & MASKLWORD;
277 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
279 coex_sta->high_priority_tx = reg_hp_tx;
280 coex_sta->high_priority_rx = reg_hp_rx;
281 coex_sta->low_priority_tx = reg_lp_tx;
282 coex_sta->low_priority_rx = reg_lp_rx;
284 if (BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
285 coex_dm->bt_status) {
287 if (coex_sta->high_priority_rx >= 15) {
288 if (cnt_overhead < 3)
291 if (cnt_overhead == 3)
292 coex_sta->is_hiPri_rx_overhead = true;
294 if (cnt_overhead > 0)
297 if (cnt_overhead == 0)
298 coex_sta->is_hiPri_rx_overhead = false;
301 coex_sta->is_hiPri_rx_overhead = false;
304 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
306 if ((coex_sta->low_priority_tx > 1050) &&
307 (!coex_sta->c2h_bt_inquiry_page))
308 coex_sta->pop_event_cnt++;
310 if ((coex_sta->low_priority_rx >= 950) &&
311 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx)
312 && (!coex_sta->under_ips) && (!coex_sta->c2h_bt_inquiry_page) &&
313 (coex_sta->bt_link_exist)) {
314 if (cnt_slave >= 2) {
315 bt_link_info->slave_role = true;
320 if (cnt_slave == 0) {
321 bt_link_info->slave_role = false;
328 if (coex_sta->is_tdma_btautoslot) {
329 if ((coex_sta->low_priority_tx >= 1300) &&
330 (coex_sta->low_priority_rx <= 150)) {
331 if (cnt_autoslot_hang >= 2) {
332 coex_sta->is_tdma_btautoslot_hang = true;
333 cnt_autoslot_hang = 2;
337 if (cnt_autoslot_hang == 0) {
338 coex_sta->is_tdma_btautoslot_hang = false;
339 cnt_autoslot_hang = 0;
345 if (coex_sta->sco_exist) {
346 if ((coex_sta->high_priority_tx >= 400) &&
347 (coex_sta->high_priority_rx >= 400))
348 coex_sta->is_eSCO_mode = false;
350 coex_sta->is_eSCO_mode = true;
353 if (!coex_sta->bt_disabled) {
355 if ((coex_sta->high_priority_tx == 0) &&
356 (coex_sta->high_priority_rx == 0) &&
357 (coex_sta->low_priority_tx == 0) &&
358 (coex_sta->low_priority_rx == 0)) {
359 num_of_bt_counter_chk++;
360 if (num_of_bt_counter_chk >= 3) {
361 halbtc8723d2ant_query_bt_info(btcoexist);
362 num_of_bt_counter_chk = 0;
369 void halbtc8723d2ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
373 boolean wifi_busy = false, wifi_under_b_mode = false,
375 boolean bt_idle = false, wl_idle = false;
376 static u8 cck_lock_counter = 0, wl_noisy_count0 = 0,
377 wl_noisy_count1 = 3, wl_noisy_count2 = 0;
378 u32 total_cnt, reg_val1, reg_val2, cck_cnt;
380 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
381 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
382 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
385 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_PHY_counter(
386 btcoexist, PHYDM_INFO_CRC32_OK_CCK);
387 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_PHY_counter(
388 btcoexist, PHYDM_INFO_CRC32_OK_LEGACY);
389 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_PHY_counter(
390 btcoexist, PHYDM_INFO_CRC32_OK_HT);
391 coex_sta->crc_ok_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
392 btcoexist, PHYDM_INFO_CRC32_OK_VHT);
394 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_PHY_counter(
395 btcoexist, PHYDM_INFO_CRC32_ERROR_CCK);
396 coex_sta->crc_err_11g = btcoexist->btc_phydm_query_PHY_counter(
397 btcoexist, PHYDM_INFO_CRC32_ERROR_LEGACY);
398 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_PHY_counter(
399 btcoexist, PHYDM_INFO_CRC32_ERROR_HT);
400 coex_sta->crc_err_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
401 btcoexist, PHYDM_INFO_CRC32_ERROR_VHT);
403 cck_cnt = coex_sta->crc_ok_cck + coex_sta->crc_err_cck;
406 if (wl_noisy_count2 < 3)
409 if (wl_noisy_count2 == 3) {
413 } else if (cck_cnt < 50) {
414 if (wl_noisy_count0 < 3)
417 if (wl_noisy_count0 == 3) {
422 if (wl_noisy_count1 < 3)
425 if (wl_noisy_count1 == 3) {
431 if (wl_noisy_count2 == 3)
432 coex_sta->wl_noisy_level = 2;
433 else if (wl_noisy_count1 == 3)
434 coex_sta->wl_noisy_level = 1;
436 coex_sta->wl_noisy_level = 0;
438 if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
439 total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
440 coex_sta->crc_ok_11n + coex_sta->crc_ok_11n_vht;
442 if ((coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_ACL_BUSY) ||
443 (coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY) ||
444 (coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_SCO_BUSY)) {
445 if (coex_sta->crc_ok_cck > (total_cnt -
446 coex_sta->crc_ok_cck)) {
447 if (cck_lock_counter < 3)
450 if (cck_lock_counter > 0)
455 if (cck_lock_counter > 0)
459 if (cck_lock_counter > 0)
463 if (!coex_sta->pre_ccklock) {
465 if (cck_lock_counter >= 3)
466 coex_sta->cck_lock = true;
468 coex_sta->cck_lock = false;
470 if (cck_lock_counter == 0)
471 coex_sta->cck_lock = false;
473 coex_sta->cck_lock = true;
476 if (coex_sta->cck_lock)
477 coex_sta->cck_ever_lock = true;
479 coex_sta->pre_ccklock = coex_sta->cck_lock;
484 void halbtc8723d2ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
486 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
487 boolean bt_hs_on = false;
488 boolean bt_busy = false;
491 coex_sta->num_of_profile = 0;
493 /* set link exist status */
494 if (!(coex_sta->bt_info & BT_INFO_8723D_2ANT_B_CONNECTION)) {
495 coex_sta->bt_link_exist = false;
496 coex_sta->pan_exist = false;
497 coex_sta->a2dp_exist = false;
498 coex_sta->hid_exist = false;
499 coex_sta->sco_exist = false;
500 } else { /* connection exists */
501 coex_sta->bt_link_exist = true;
502 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_FTP) {
503 coex_sta->pan_exist = true;
504 coex_sta->num_of_profile++;
506 coex_sta->pan_exist = false;
508 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_A2DP) {
509 coex_sta->a2dp_exist = true;
510 coex_sta->num_of_profile++;
512 coex_sta->a2dp_exist = false;
514 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_HID) {
515 coex_sta->hid_exist = true;
516 coex_sta->num_of_profile++;
518 coex_sta->hid_exist = false;
520 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) {
521 coex_sta->sco_exist = true;
522 coex_sta->num_of_profile++;
524 coex_sta->sco_exist = false;
528 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
530 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
531 bt_link_info->sco_exist = coex_sta->sco_exist;
532 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
533 bt_link_info->pan_exist = coex_sta->pan_exist;
534 bt_link_info->hid_exist = coex_sta->hid_exist;
535 bt_link_info->acl_busy = coex_sta->acl_busy;
537 /* work around for HS mode. */
539 bt_link_info->pan_exist = true;
540 bt_link_info->bt_link_exist = true;
543 /* check if Sco only */
544 if (bt_link_info->sco_exist &&
545 !bt_link_info->a2dp_exist &&
546 !bt_link_info->pan_exist &&
547 !bt_link_info->hid_exist)
548 bt_link_info->sco_only = true;
550 bt_link_info->sco_only = false;
552 /* check if A2dp only */
553 if (!bt_link_info->sco_exist &&
554 bt_link_info->a2dp_exist &&
555 !bt_link_info->pan_exist &&
556 !bt_link_info->hid_exist)
557 bt_link_info->a2dp_only = true;
559 bt_link_info->a2dp_only = false;
561 /* check if Pan only */
562 if (!bt_link_info->sco_exist &&
563 !bt_link_info->a2dp_exist &&
564 bt_link_info->pan_exist &&
565 !bt_link_info->hid_exist)
566 bt_link_info->pan_only = true;
568 bt_link_info->pan_only = false;
570 /* check if Hid only */
571 if (!bt_link_info->sco_exist &&
572 !bt_link_info->a2dp_exist &&
573 !bt_link_info->pan_exist &&
574 bt_link_info->hid_exist)
575 bt_link_info->hid_only = true;
577 bt_link_info->hid_only = false;
579 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_INQ_PAGE) {
580 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_INQ_PAGE;
581 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
582 "[BTCoex], BtInfoNotify(), BT Inq/page!!!\n");
583 } else if (!(coex_sta->bt_info & BT_INFO_8723D_2ANT_B_CONNECTION)) {
584 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
585 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
586 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
587 } else if (coex_sta->bt_info == BT_INFO_8723D_2ANT_B_CONNECTION) {
588 /* connection exists but no busy */
589 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE;
590 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
591 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
592 } else if (((coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) ||
593 (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_BUSY)) &&
594 (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_ACL_BUSY)) {
595 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY;
596 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
597 "[BTCoex], BtInfoNotify(), BT ACL SCO busy!!!\n");
598 } else if ((coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) ||
599 (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_BUSY)) {
600 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_SCO_BUSY;
601 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
602 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
603 } else if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_ACL_BUSY) {
604 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_ACL_BUSY;
605 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
606 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
608 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_MAX;
609 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
610 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
613 BTC_TRACE(trace_buf);
615 if ((BT_8723D_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
616 (BT_8723D_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
617 (BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
622 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
625 void halbtc8723d2ant_update_wifi_channel_info(IN struct btc_coexist *btcoexist,
628 u8 h2c_parameter[3] = {0};
630 u8 wifi_central_chnl;
632 /* only 2.4G we need to inform bt the chnl mask */
633 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
635 if ((BTC_MEDIA_CONNECT == type) &&
636 (wifi_central_chnl <= 14)) {
638 0x1; /* enable BT AFH skip WL channel for 8723d because BT Rx LO interference */
639 /* h2c_parameter[0] = 0x0; */
640 h2c_parameter[1] = wifi_central_chnl;
641 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
642 if (BTC_WIFI_BW_HT40 == wifi_bw)
643 h2c_parameter[2] = 0x30;
645 h2c_parameter[2] = 0x20;
648 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
649 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
650 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
652 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
656 void halbtc8723d2ant_set_fw_dac_swing_level(IN struct btc_coexist *btcoexist,
659 u8 h2c_parameter[1] = {0};
661 /* There are several type of dacswing */
662 /* 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
663 h2c_parameter[0] = dac_swing_lvl;
665 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
668 void halbtc8723d2ant_fw_dac_swing_lvl(IN struct btc_coexist *btcoexist,
669 IN boolean force_exec, IN u8 fw_dac_swing_lvl)
671 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
674 if (coex_dm->pre_fw_dac_swing_lvl ==
675 coex_dm->cur_fw_dac_swing_lvl)
679 halbtc8723d2ant_set_fw_dac_swing_level(btcoexist,
680 coex_dm->cur_fw_dac_swing_lvl);
682 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
685 void halbtc8723d2ant_set_fw_dec_bt_pwr(IN struct btc_coexist *btcoexist,
686 IN u8 dec_bt_pwr_lvl)
688 u8 h2c_parameter[1] = {0};
690 h2c_parameter[0] = dec_bt_pwr_lvl;
692 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
695 void halbtc8723d2ant_dec_bt_pwr(IN struct btc_coexist *btcoexist,
696 IN boolean force_exec, IN u8 dec_bt_pwr_lvl)
698 coex_dm->cur_bt_dec_pwr_lvl = dec_bt_pwr_lvl;
701 if (coex_dm->pre_bt_dec_pwr_lvl == coex_dm->cur_bt_dec_pwr_lvl)
704 halbtc8723d2ant_set_fw_dec_bt_pwr(btcoexist,
705 coex_dm->cur_bt_dec_pwr_lvl);
707 coex_dm->pre_bt_dec_pwr_lvl = coex_dm->cur_bt_dec_pwr_lvl;
710 void halbtc8723d2ant_set_fw_low_penalty_ra(IN struct btc_coexist
711 *btcoexist, IN boolean low_penalty_ra)
714 u8 h2c_parameter[6] = {0};
716 h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
718 if (low_penalty_ra) {
719 h2c_parameter[1] |= BIT(0);
721 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
722 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
723 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
724 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
727 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
731 void halbtc8723d2ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
732 IN boolean force_exec, IN boolean low_penalty_ra)
735 coex_dm->cur_low_penalty_ra = low_penalty_ra;
738 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
742 halbtc8723d2ant_set_fw_low_penalty_ra(btcoexist,
743 coex_dm->cur_low_penalty_ra);
747 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 15);
749 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 0);
751 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
756 void halbtc8723d2ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
757 IN boolean enable_auto_report)
759 u8 h2c_parameter[1] = {0};
761 h2c_parameter[0] = 0;
763 if (enable_auto_report)
764 h2c_parameter[0] |= BIT(0);
766 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
769 void halbtc8723d2ant_bt_auto_report(IN struct btc_coexist *btcoexist,
770 IN boolean force_exec, IN boolean enable_auto_report)
772 coex_dm->cur_bt_auto_report = enable_auto_report;
775 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
778 halbtc8723d2ant_set_bt_auto_report(btcoexist,
779 coex_dm->cur_bt_auto_report);
781 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
784 void halbtc8723d2ant_write_score_board(
785 IN struct btc_coexist *btcoexist,
791 static u16 originalval = 0x8002;
794 originalval = originalval | bitpos;
796 originalval = originalval & (~bitpos);
799 btcoexist->btc_write_2byte(btcoexist, 0xaa, originalval);
803 void halbtc8723d2ant_read_score_board(
804 IN struct btc_coexist *btcoexist,
805 IN u16 *score_board_val
809 *score_board_val = (btcoexist->btc_read_2byte(btcoexist,
814 void halbtc8723d2ant_post_state_to_bt(
815 IN struct btc_coexist *btcoexist,
820 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
821 "[BTCoex], halbtc8723d2ant_post_state_to_bt: type = %d, state =%d\n",
823 BTC_TRACE(trace_buf);
825 halbtc8723d2ant_write_score_board(btcoexist, (u16) type, state);
829 boolean halbtc8723d2ant_is_wifibt_status_changed(IN struct btc_coexist
833 static boolean pre_wifi_busy = false, pre_under_4way = false,
834 pre_bt_hs_on = false, pre_bt_off = false, pre_bt_slave = false;
835 static u8 pre_hid_busy_num = 0, pre_wl_noisy_level = 0;
836 boolean wifi_busy = false, under_4way = false, bt_hs_on = false;
837 boolean wifi_connected = false;
838 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
840 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
842 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
843 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
844 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
847 if (coex_sta->bt_disabled != pre_bt_off) {
848 pre_bt_off = coex_sta->bt_disabled;
850 if (coex_sta->bt_disabled)
851 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
852 "[BTCoex], BT is disabled !!\n");
854 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
855 "[BTCoex], BT is enabled !!\n");
857 BTC_TRACE(trace_buf);
859 coex_sta->bt_coex_supported_feature = 0;
860 coex_sta->bt_coex_supported_version = 0;
861 coex_sta->bt_ble_scan_type = 0;
862 coex_sta->bt_ble_scan_para[0] = 0;
863 coex_sta->bt_ble_scan_para[1] = 0;
864 coex_sta->bt_ble_scan_para[2] = 0;
865 coex_sta->bt_reg_vendor_ac = 0xffff;
866 coex_sta->bt_reg_vendor_ae = 0xffff;
870 if (wifi_connected) {
871 if (wifi_busy != pre_wifi_busy) {
872 pre_wifi_busy = wifi_busy;
875 halbtc8723d2ant_post_state_to_bt(btcoexist,
876 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, true);
878 halbtc8723d2ant_post_state_to_bt(btcoexist,
879 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, false);
882 if (under_4way != pre_under_4way) {
883 pre_under_4way = under_4way;
886 if (bt_hs_on != pre_bt_hs_on) {
887 pre_bt_hs_on = bt_hs_on;
890 if (coex_sta->wl_noisy_level != pre_wl_noisy_level) {
891 pre_wl_noisy_level = coex_sta->wl_noisy_level;
896 if (!coex_sta->bt_disabled) {
897 if (coex_sta->hid_busy_num != pre_hid_busy_num) {
898 pre_hid_busy_num = coex_sta->hid_busy_num;
903 if (bt_link_info->slave_role != pre_bt_slave) {
904 pre_bt_slave = bt_link_info->slave_role;
911 void halbtc8723d2ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
913 static u32 bt_disable_cnt = 0;
914 boolean bt_active = true, bt_disabled = false;
917 /* This function check if bt is disabled */
919 if (coex_sta->high_priority_tx == 0 &&
920 coex_sta->high_priority_rx == 0 &&
921 coex_sta->low_priority_tx == 0 &&
922 coex_sta->low_priority_rx == 0)
924 if (coex_sta->high_priority_tx == 0xffff &&
925 coex_sta->high_priority_rx == 0xffff &&
926 coex_sta->low_priority_tx == 0xffff &&
927 coex_sta->low_priority_rx == 0xffff)
933 /* Read BT on/off status from scoreboard[1], enable this only if BT patch support this feature */
934 halbtc8723d2ant_read_score_board(btcoexist, &u16tmp);
936 bt_active = u16tmp & BIT(1);
944 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
949 if (bt_disable_cnt >= 2) {
954 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
959 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, false);
961 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, true);
963 if (coex_sta->bt_disabled != bt_disabled) {
964 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
965 "[BTCoex], BT is from %s to %s!!\n",
966 (coex_sta->bt_disabled ? "disabled" : "enabled"),
967 (bt_disabled ? "disabled" : "enabled"));
968 BTC_TRACE(trace_buf);
969 coex_sta->bt_disabled = bt_disabled;
976 void halbtc8723d2ant_enable_gnt_to_gpio(IN struct btc_coexist *btcoexist,
979 #if BT_8723D_2ANT_COEX_DBG
981 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x1);
983 /* enable GNT_BT to GPIO debug */
984 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x0);
985 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x0);
987 /* 0x48[20] = 0 for GPIO14 = GNT_WL*/
988 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4a, 0x10, 0x0);
989 /* 0x40[17] = 0 for GPIO14 = GNT_WL*/
990 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x42, 0x02, 0x0);
992 /* 0x66[9] = 0 for GPIO15 = GNT_BT*/
993 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x02, 0x0);
995 for GPIO15 = GNT_BT*/
996 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x66, 0x80, 0x0);
997 /* 0x8[8] = 0 for GPIO15 = GNT_BT*/
998 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x9, 0x1, 0x0);
1000 /* BT Vendor Reg 0x76[0] = 0 for GPIO15 = GNT_BT, this is not set here*/
1002 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x0);
1004 /* Disable GNT_BT debug to GPIO, and enable chip_wakeup_host */
1005 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x1);
1006 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x1);
1008 /* 0x48[20] = 0 for GPIO14 = GNT_WL*/
1009 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4a, 0x10, 0x1);
1015 u32 halbtc8723d2ant_ltecoex_indirect_read_reg(IN struct btc_coexist *btcoexist,
1018 u32 j = 0, delay_count = 0;
1021 /* wait for ready bit before access 0x7c0 */
1022 btcoexist->btc_write_4byte(btcoexist, 0x7c0, 0x800F0000 | reg_addr);
1025 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3) & BIT(5)) == 0) {
1028 if (delay_count >= 10) {
1036 return btcoexist->btc_read_4byte(btcoexist,
1037 0x7c8); /* get read data */
1041 void halbtc8723d2ant_ltecoex_indirect_write_reg(IN struct btc_coexist
1043 IN u16 reg_addr, IN u32 bit_mask, IN u32 reg_value)
1045 u32 val, i = 0, j = 0, bitpos = 0, delay_count = 0;
1048 if (bit_mask == 0x0)
1050 if (bit_mask == 0xffffffff) {
1051 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1052 reg_value); /* put write data */
1054 /* wait for ready bit before access 0x7c0 */
1056 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3) & BIT(5)) == 0) {
1059 if (delay_count >= 10) {
1067 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1068 0xc00F0000 | reg_addr);
1070 for (i = 0; i <= 31; i++) {
1071 if (((bit_mask >> i) & 0x1) == 0x1) {
1077 /* read back register value before write */
1078 val = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1080 val = (val & (~bit_mask)) | (reg_value << bitpos);
1082 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1083 val); /* put write data */
1085 /* wait for ready bit before access 0x7c0 */
1087 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3) & BIT(5)) == 0) {
1090 if (delay_count >= 10) {
1098 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1099 0xc00F0000 | reg_addr);
1105 void halbtc8723d2ant_ltecoex_enable(IN struct btc_coexist *btcoexist,
1110 val = (enable) ? 1 : 0;
1111 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, 0x38, 0x80,
1116 void halbtc8723d2ant_ltecoex_pathcontrol_owner(IN struct btc_coexist *btcoexist,
1117 IN boolean wifi_control)
1121 val = (wifi_control) ? 1 : 0;
1122 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x4,
1123 val); /* 0x70[26] */
1127 void halbtc8723d2ant_ltecoex_set_gnt_bt(IN struct btc_coexist *btcoexist,
1128 IN u8 control_block, IN boolean sw_control, IN u8 state)
1130 u32 val = 0, val_orig = 0;
1134 else if (state & 0x1)
1139 val_orig = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1142 switch (control_block) {
1143 case BT_8723D_2ANT_GNT_BLOCK_RFC_BB:
1145 val = ((val << 14) | (val << 10)) | (val_orig & 0xffff33ff);
1147 case BT_8723D_2ANT_GNT_BLOCK_RFC:
1148 val = (val << 14) | (val_orig & 0xffff3fff);
1150 case BT_8723D_2ANT_GNT_BLOCK_BB:
1151 val = (val << 10) | (val_orig & 0xfffff3ff);
1155 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist,
1156 0x38, 0xffffffff, val);
1160 void halbtc8723d2ant_ltecoex_set_gnt_wl(IN struct btc_coexist *btcoexist,
1161 IN u8 control_block, IN boolean sw_control, IN u8 state)
1163 u32 val = 0, val_orig = 0;
1167 else if (state & 0x1)
1172 val_orig = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1175 switch (control_block) {
1176 case BT_8723D_2ANT_GNT_BLOCK_RFC_BB:
1178 val = ((val << 12) | (val << 8)) | (val_orig & 0xffffccff);
1180 case BT_8723D_2ANT_GNT_BLOCK_RFC:
1181 val = (val << 12) | (val_orig & 0xffffcfff);
1183 case BT_8723D_2ANT_GNT_BLOCK_BB:
1184 val = (val << 8) | (val_orig & 0xfffffcff);
1188 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist,
1189 0x38, 0xffffffff, val);
1192 void halbtc8723d2ant_ltecoex_set_coex_table(IN struct btc_coexist *btcoexist,
1193 IN u8 table_type, IN u16 table_content)
1195 u16 reg_addr = 0x0000;
1197 switch (table_type) {
1198 case BT_8723D_2ANT_CTT_WL_VS_LTE:
1201 case BT_8723D_2ANT_CTT_BT_VS_LTE:
1206 if (reg_addr != 0x0000)
1207 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1208 0xffff, table_content); /* 0xa0[15:0] or 0xa4[15:0] */
1214 void halbtc8723d2ant_ltecoex_set_break_table(IN struct btc_coexist *btcoexist,
1215 IN u8 table_type, IN u8 table_content)
1217 u16 reg_addr = 0x0000;
1219 switch (table_type) {
1220 case BT_8723D_2ANT_LBTT_WL_BREAK_LTE:
1223 case BT_8723D_2ANT_LBTT_BT_BREAK_LTE:
1226 case BT_8723D_2ANT_LBTT_LTE_BREAK_WL:
1229 case BT_8723D_2ANT_LBTT_LTE_BREAK_BT:
1234 if (reg_addr != 0x0000)
1235 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1236 0xff, table_content); /* 0xa8[15:0] or 0xb4[15:0] */
1241 void halbtc8723d2ant_set_wltoggle_coex_table(IN struct btc_coexist *btcoexist,
1242 IN boolean force_exec, IN u8 interval,
1243 IN u8 val0x6c4_b0, IN u8 val0x6c4_b1, IN u8 val0x6c4_b2,
1246 static u8 pre_h2c_parameter[6] = {0};
1247 u8 cur_h2c_parameter[6] = {0};
1248 u8 i, match_cnt = 0;
1250 cur_h2c_parameter[0] = 0x7; /* op_code, 0x7= wlan toggle slot*/
1252 cur_h2c_parameter[1] = interval;
1253 cur_h2c_parameter[2] = val0x6c4_b0;
1254 cur_h2c_parameter[3] = val0x6c4_b1;
1255 cur_h2c_parameter[4] = val0x6c4_b2;
1256 cur_h2c_parameter[5] = val0x6c4_b3;
1259 for (i = 1; i <= 5; i++) {
1260 if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
1270 for (i = 1; i <= 5; i++)
1271 pre_h2c_parameter[i] = cur_h2c_parameter[i];
1273 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, cur_h2c_parameter);
1276 void halbtc8723d2ant_set_coex_table(IN struct btc_coexist *btcoexist,
1277 IN u32 val0x6c0, IN u32 val0x6c4, IN u32 val0x6c8, IN u8 val0x6cc)
1279 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
1281 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
1283 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
1285 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
1288 void halbtc8723d2ant_coex_table(IN struct btc_coexist *btcoexist,
1289 IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
1290 IN u32 val0x6c8, IN u8 val0x6cc)
1292 coex_dm->cur_val0x6c0 = val0x6c0;
1293 coex_dm->cur_val0x6c4 = val0x6c4;
1294 coex_dm->cur_val0x6c8 = val0x6c8;
1295 coex_dm->cur_val0x6cc = val0x6cc;
1298 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1299 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1300 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1301 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1304 halbtc8723d2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1307 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1308 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1309 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1310 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1313 void halbtc8723d2ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
1314 IN boolean force_exec, IN u8 type)
1319 coex_sta->coex_table_type = type;
1321 if (coex_sta->concurrent_rx_mode_on == true) {
1322 break_table = 0xf0ffffff; /* set WL hi-pri can break BT */
1324 0xb; /* set Tx response = Hi-Pri (ex: Transmitting ACK,BA,CTS) */
1326 break_table = 0xffffff;
1332 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1333 0xffffffff, 0xffffffff, break_table, select_table);
1336 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1337 0x55555555, 0x5a5a5a5a, break_table, select_table);
1340 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1341 0x5a5a5a5a, 0x5a5a5a5a, break_table, select_table);
1344 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1345 0xaa555555, 0xaa5a5a5a, break_table, select_table);
1348 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1349 0x55555555, 0x5a5a5a5a, break_table, select_table);
1352 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1353 0x55555555, 0x55555555, break_table, select_table);
1356 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1357 0xa5555555, 0xfafafafa, break_table, select_table);
1360 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1361 0xa5555555, 0xaa5a5a5a, break_table, select_table);
1364 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1365 0xa5555555, 0xfafafafa, break_table, select_table);
1368 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1369 0x5a5a5a5a, 0xaaaa5aaa, break_table, select_table);
1376 void halbtc8723d2ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1379 u8 h2c_parameter[1] = {0};
1382 h2c_parameter[0] |= BIT(0); /* function enable */
1385 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1388 void halbtc8723d2ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1389 IN boolean force_exec, IN boolean enable)
1391 coex_dm->cur_ignore_wlan_act = enable;
1394 if (coex_dm->pre_ignore_wlan_act ==
1395 coex_dm->cur_ignore_wlan_act)
1398 halbtc8723d2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1400 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1403 void halbtc8723d2ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
1404 IN u8 lps_val, IN u8 rpwm_val)
1409 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1410 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1413 void halbtc8723d2ant_lps_rpwm(IN struct btc_coexist *btcoexist,
1414 IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
1416 coex_dm->cur_lps = lps_val;
1417 coex_dm->cur_rpwm = rpwm_val;
1420 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1421 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1424 halbtc8723d2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1426 coex_dm->pre_lps = coex_dm->cur_lps;
1427 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1430 void halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1431 IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
1434 u8 h2c_parameter[5] = {0, 0, 0, 0x40, 0};
1436 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1438 if (lps_mode) { /* already under LPS state */
1440 /* keep state under LPS, do nothing. */
1442 /* will leave LPS state, turn off psTdma first */
1443 /*halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1445 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1448 } else { /* NO PS state */
1450 /* will enter LPS state, turn off psTdma first */
1451 /*halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1453 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1456 /* keep state under NO PS state, do nothing. */
1461 void halbtc8723d2ant_power_save_state(IN struct btc_coexist *btcoexist,
1462 IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
1464 boolean low_pwr_disable = false;
1467 case BTC_PS_WIFI_NATIVE:
1468 /* recover to original 32k low power setting */
1469 low_pwr_disable = false;
1470 btcoexist->btc_set(btcoexist,
1471 BTC_SET_ACT_DISABLE_LOW_POWER,
1473 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
1475 coex_sta->force_lps_on = false;
1478 halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1480 halbtc8723d2ant_lps_rpwm(btcoexist, NORMAL_EXEC,
1482 /* when coex force to enter LPS, do not enter 32k low power. */
1483 low_pwr_disable = true;
1484 btcoexist->btc_set(btcoexist,
1485 BTC_SET_ACT_DISABLE_LOW_POWER,
1487 /* power save must executed before psTdma. */
1488 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
1490 coex_sta->force_lps_on = true;
1492 case BTC_PS_LPS_OFF:
1493 halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1495 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1497 coex_sta->force_lps_on = false;
1506 void halbtc8723d2ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
1507 IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
1509 u8 h2c_parameter[5] = {0};
1510 u8 real_byte1 = byte1, real_byte5 = byte5;
1511 boolean ap_enable = false;
1512 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1515 coex_sta->is_tdma_btautoslot = true;
1517 coex_sta->is_tdma_btautoslot = false;
1519 /* release bt-auto slot for auto-slot hang is detected!! */
1520 if (coex_sta->is_tdma_btautoslot)
1521 if ((coex_sta->is_tdma_btautoslot_hang) ||
1522 (bt_link_info->slave_role))
1523 byte5 = byte5 & 0xfb;
1525 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1529 if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1530 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1531 "[BTCoex], FW for AP mode\n");
1532 BTC_TRACE(trace_buf);
1533 real_byte1 &= ~BIT(4);
1534 real_byte1 |= BIT(5);
1536 real_byte5 |= BIT(5);
1537 real_byte5 &= ~BIT(6);
1539 halbtc8723d2ant_power_save_state(btcoexist,
1540 BTC_PS_WIFI_NATIVE, 0x0,
1543 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1545 halbtc8723d2ant_power_save_state(
1546 btcoexist, BTC_PS_LPS_ON, 0x50,
1549 halbtc8723d2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1555 h2c_parameter[0] = real_byte1;
1556 h2c_parameter[1] = byte2;
1557 h2c_parameter[2] = byte3;
1558 h2c_parameter[3] = byte4;
1559 h2c_parameter[4] = real_byte5;
1561 coex_dm->ps_tdma_para[0] = real_byte1;
1562 coex_dm->ps_tdma_para[1] = byte2;
1563 coex_dm->ps_tdma_para[2] = byte3;
1564 coex_dm->ps_tdma_para[3] = byte4;
1565 coex_dm->ps_tdma_para[4] = real_byte5;
1567 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1570 void halbtc8723d2ant_ps_tdma(IN struct btc_coexist *btcoexist,
1571 IN boolean force_exec, IN boolean turn_on, IN u8 type)
1574 static u8 psTdmaByte4Modify = 0x0, pre_psTdmaByte4Modify = 0x0;
1575 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1578 coex_dm->cur_ps_tdma_on = turn_on;
1579 coex_dm->cur_ps_tdma = type;
1581 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1582 if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1583 psTdmaByte4Modify = 0x1;
1585 psTdmaByte4Modify = 0x0;
1587 if (pre_psTdmaByte4Modify != psTdmaByte4Modify) {
1590 pre_psTdmaByte4Modify = psTdmaByte4Modify;
1594 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1595 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1599 if (coex_dm->cur_ps_tdma_on) {
1600 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1601 "[BTCoex], ********** TDMA(on, %d) **********\n",
1602 coex_dm->cur_ps_tdma);
1603 BTC_TRACE(trace_buf);
1605 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
1606 0x1); /* enable TBTT nterrupt */
1608 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1609 "[BTCoex], ********** TDMA(off, %d) **********\n",
1610 coex_dm->cur_ps_tdma);
1611 BTC_TRACE(trace_buf);
1618 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1620 0x54 | psTdmaByte4Modify);
1624 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1626 0x11 | psTdmaByte4Modify);
1629 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1631 0x10 | psTdmaByte4Modify);
1634 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1636 0x10 | psTdmaByte4Modify);
1639 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1641 0x10 | psTdmaByte4Modify);
1644 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1646 0x10 | psTdmaByte4Modify);
1649 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1651 0x10 | psTdmaByte4Modify);
1654 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1659 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1664 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1666 0x10 | psTdmaByte4Modify);
1669 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1670 0x35, 0x03, 0x11, 0x11);
1673 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1675 0x10 | psTdmaByte4Modify);
1678 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1683 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1688 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1693 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1698 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1703 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1708 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1710 0x10 | psTdmaByte4Modify);
1713 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1715 0x54 | psTdmaByte4Modify);
1718 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1720 0x11 | psTdmaByte4Modify);
1723 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1725 0x50 | psTdmaByte4Modify);
1728 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1730 0x50 | psTdmaByte4Modify);
1733 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1735 0x50 | psTdmaByte4Modify);
1738 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1740 0x50 | psTdmaByte4Modify);
1743 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1745 0x50 | psTdmaByte4Modify);
1748 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1750 0x50 | psTdmaByte4Modify);
1753 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x55,
1755 0x54 | psTdmaByte4Modify);
1758 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x55,
1760 0x50 | psTdmaByte4Modify);
1763 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x65,
1765 0x11 | psTdmaByte4Modify);
1768 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1770 0x50 | psTdmaByte4Modify);
1774 /* disable PS tdma */
1777 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1778 0x0, 0x0, 0x40, 0x0);
1781 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1782 0x0, 0x0, 0x48, 0x0);
1785 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1786 0x0, 0x0, 0x40, 0x0);
1791 /* update pre state */
1792 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1793 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1796 void halbtc8723d2ant_set_ant_path(IN struct btc_coexist *btcoexist,
1797 IN u8 ant_pos_type, IN boolean force_exec,
1800 struct btc_board_info *board_info = &btcoexist->board_info;
1802 boolean pg_ext_switch = false, is_hw_ant_div_on = false;
1803 u8 h2c_parameter[2] = {0};
1804 u32 cnt_bt_cal_chk = 0;
1805 u8 u8tmp0 = 0, u8tmp1 = 0;
1806 boolean is_in_mp_mode = false;
1807 u32 u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
1808 u16 u16tmp0 = 0, u16tmp1 = 0;
1811 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1814 /* To avoid indirect access fail */
1815 if (((u32tmp1 & 0xf000) >> 12) != ((u32tmp1 & 0x0f00) >> 8)) {
1817 coex_sta->gnt_error_cnt++;
1821 #if BT_8723D_2ANT_COEX_DBG
1822 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
1823 u16tmp0 = btcoexist->btc_read_2byte(btcoexist, 0xaa);
1824 u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1825 u8tmp1 = btcoexist->btc_read_1byte(btcoexist, 0x73);
1826 u8tmp0 = btcoexist->btc_read_1byte(btcoexist, 0x67);
1828 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1829 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(Before Set Ant Pat)\n",
1830 u8tmp0, u16tmp1, u8tmp1);
1831 BTC_TRACE(trace_buf);
1833 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1834 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x, 0xaa = 0x%x (Before Set Ant Path)\n",
1835 u32tmp1, u32tmp2, u16tmp0);
1836 BTC_TRACE(trace_buf);
1839 coex_dm->cur_ant_pos_type = ant_pos_type;
1842 if (coex_dm->cur_ant_pos_type == coex_dm->pre_ant_pos_type) {
1844 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1845 "[BTCoex], ********** Skip Antenna Path Setup because no change!!**********\n");
1846 BTC_TRACE(trace_buf);
1851 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
1854 case BT_8723D_2ANT_PHASE_COEX_POWERON:
1855 /* Set Path control to WL */
1856 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
1859 /* set Path control owner to WL at initial step */
1860 halbtc8723d2ant_ltecoex_pathcontrol_owner(btcoexist,
1861 BT_8723D_2ANT_PCO_BTSIDE);
1863 /* set GNT_BT to SW high */
1864 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1865 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1866 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1867 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1868 /* Set GNT_WL to SW low */
1869 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1870 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1871 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1872 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1874 if (BTC_ANT_PATH_AUTO == ant_pos_type)
1875 ant_pos_type = BTC_ANT_PATH_WIFI;
1877 coex_sta->run_time_state = false;
1880 case BT_8723D_2ANT_PHASE_COEX_INIT:
1881 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
1882 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
1884 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
1885 halbtc8723d2ant_ltecoex_set_coex_table(
1887 BT_8723D_2ANT_CTT_WL_VS_LTE,
1890 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
1891 halbtc8723d2ant_ltecoex_set_coex_table(
1893 BT_8723D_2ANT_CTT_BT_VS_LTE,
1896 /* Wait If BT IQK running, because Path control owner is at BT during BT IQK (setup by WiFi firmware) */
1897 while (cnt_bt_cal_chk <= 20) {
1898 u8tmp0 = btcoexist->btc_read_1byte(
1902 if (u8tmp0 & BIT(0)) {
1906 "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
1915 "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
1924 /* Set Path control to WL */
1925 btcoexist->btc_write_1byte_bitmask(btcoexist,
1928 /* set Path control owner to WL at initial step */
1929 halbtc8723d2ant_ltecoex_pathcontrol_owner(
1931 BT_8723D_2ANT_PCO_WLSIDE);
1933 /* set GNT_BT to SW high */
1934 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1935 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1936 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1937 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1938 /* Set GNT_WL to SW high */
1939 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1940 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1941 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1942 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1944 coex_sta->run_time_state = false;
1946 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
1947 if (board_info->btdm_ant_pos ==
1948 BTC_ANTENNA_AT_MAIN_PORT)
1950 BTC_ANT_WIFI_AT_MAIN;
1953 BTC_ANT_WIFI_AT_AUX;
1957 case BT_8723D_2ANT_PHASE_WLANONLY_INIT:
1958 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
1959 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
1961 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
1962 halbtc8723d2ant_ltecoex_set_coex_table(
1964 BT_8723D_2ANT_CTT_WL_VS_LTE,
1967 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
1968 halbtc8723d2ant_ltecoex_set_coex_table(
1970 BT_8723D_2ANT_CTT_BT_VS_LTE,
1973 /* Set Path control to WL */
1974 btcoexist->btc_write_1byte_bitmask(btcoexist,
1977 /* set Path control owner to WL at initial step */
1978 halbtc8723d2ant_ltecoex_pathcontrol_owner(
1980 BT_8723D_2ANT_PCO_WLSIDE);
1982 /* set GNT_BT to SW Low */
1983 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1984 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1985 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1986 BT_8723D_2ANT_SIG_STA_SET_TO_LOW);
1987 /* Set GNT_WL to SW high */
1988 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1989 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1990 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1991 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1993 coex_sta->run_time_state = false;
1995 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
1996 if (board_info->btdm_ant_pos ==
1997 BTC_ANTENNA_AT_MAIN_PORT)
1999 BTC_ANT_WIFI_AT_MAIN;
2002 BTC_ANT_WIFI_AT_AUX;
2006 case BT_8723D_2ANT_PHASE_WLAN_OFF:
2007 /* Disable LTE Coex Function in WiFi side */
2008 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
2010 /* Set Path control to BT */
2011 btcoexist->btc_write_1byte_bitmask(btcoexist,
2014 /* set Path control owner to BT */
2015 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2017 BT_8723D_2ANT_PCO_BTSIDE);
2019 coex_sta->run_time_state = false;
2021 case BT_8723D_2ANT_PHASE_2G_RUNTIME:
2023 /* wait for WL/BT IQK finish, keep 0x38 = 0xff00 for WL IQK */
2024 while (cnt_bt_cal_chk <= 20) {
2025 u8tmp0 = btcoexist->btc_read_1byte(
2029 u8tmp1 = btcoexist->btc_read_1byte(
2034 if ((u8tmp0 & BIT(0)) ||
2035 (u8tmp1 & BIT(0))) {
2036 BTC_SPRINTF(trace_buf,
2038 "[BTCoex], ########### WL or BT is IQK (wait cnt=%d)\n",
2040 BTC_TRACE(trace_buf);
2043 BTC_SPRINTF(trace_buf,
2045 "[BTCoex], ********** WL and BT is NOT IQK (wait cnt=%d)\n",
2047 BTC_TRACE(trace_buf);
2052 /* Set Path control to WL */
2053 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x80, 0x1);*/
2055 /* set Path control owner to WL at runtime step */
2056 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2058 BT_8723D_2ANT_PCO_WLSIDE);
2061 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2062 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2063 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_PTA,
2064 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2066 /* Set GNT_WL to PTA */
2067 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2068 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2069 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_PTA,
2070 BT_8723D_2ANT_SIG_STA_SET_BY_HW);
2072 coex_sta->run_time_state = true;
2074 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2075 if (board_info->btdm_ant_pos ==
2076 BTC_ANTENNA_AT_MAIN_PORT)
2078 BTC_ANT_WIFI_AT_MAIN;
2081 BTC_ANT_WIFI_AT_AUX;
2085 case BT_8723D_2ANT_PHASE_BTMPMODE:
2086 /* Disable LTE Coex Function in WiFi side */
2087 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
2089 /* Set Path control to WL */
2090 btcoexist->btc_write_1byte_bitmask(btcoexist,
2093 /* set Path control owner to WL */
2094 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2096 BT_8723D_2ANT_PCO_WLSIDE);
2098 /* set GNT_BT to SW Hi */
2099 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2100 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2101 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2102 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2104 /* Set GNT_WL to SW Lo */
2105 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2106 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2107 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2108 BT_8723D_2ANT_SIG_STA_SET_TO_LOW);
2110 coex_sta->run_time_state = false;
2112 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2113 if (board_info->btdm_ant_pos ==
2114 BTC_ANTENNA_AT_MAIN_PORT)
2116 BTC_ANT_WIFI_AT_MAIN;
2119 BTC_ANT_WIFI_AT_AUX;
2123 case BT_8723D_2ANT_PHASE_ANTENNA_DET:
2125 /* Set Path control to WL */
2126 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
2129 /* set Path control owner to WL */
2130 halbtc8723d2ant_ltecoex_pathcontrol_owner(btcoexist,
2131 BT_8723D_2ANT_PCO_WLSIDE);
2133 /* Set Antenna Path, both GNT_WL/GNT_BT = 1, and control by SW */
2134 /* set GNT_BT to SW high */
2135 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2136 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2137 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2138 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2140 /* Set GNT_WL to SW high */
2141 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2142 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2143 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2144 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2146 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2147 ant_pos_type = BTC_ANT_WIFI_AT_AUX;
2149 coex_sta->run_time_state = false;
2154 is_hw_ant_div_on = board_info->ant_div_cfg;
2156 if ((is_hw_ant_div_on) && (phase != BT_8723D_2ANT_PHASE_ANTENNA_DET))
2157 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x140);
2158 else if ((is_hw_ant_div_on == false) &&
2159 (phase != BT_8723D_2ANT_PHASE_WLAN_OFF)) {
2161 switch (ant_pos_type) {
2162 case BTC_ANT_WIFI_AT_MAIN:
2164 btcoexist->btc_write_2byte(btcoexist,
2167 case BTC_ANT_WIFI_AT_AUX:
2169 btcoexist->btc_write_2byte(btcoexist,
2176 #if BT_8723D_2ANT_COEX_DBG
2177 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
2178 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
2179 u16tmp0 = btcoexist->btc_read_2byte(btcoexist, 0xaa);
2180 u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
2181 u8tmp1 = btcoexist->btc_read_1byte(btcoexist, 0x73);
2182 u8tmp0 = btcoexist->btc_read_1byte(btcoexist, 0x67);
2184 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2185 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(After Set Ant Pat)\n",
2186 u8tmp0, u16tmp1, u8tmp1);
2187 BTC_TRACE(trace_buf);
2189 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2190 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x, 0xaa= 0x%x (After Set Ant Path)\n",
2191 u32tmp1, u32tmp2, u16tmp0);
2192 BTC_TRACE(trace_buf);
2197 u8 halbtc8723d2ant_action_algorithm(IN struct btc_coexist *btcoexist)
2199 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2200 boolean bt_hs_on = false;
2201 u8 algorithm = BT_8723D_2ANT_COEX_ALGO_UNDEFINED;
2202 u8 num_of_diff_profile = 0;
2204 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2206 if (!bt_link_info->bt_link_exist) {
2207 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2208 "[BTCoex], No BT link exists!!!\n");
2209 BTC_TRACE(trace_buf);
2213 if (bt_link_info->sco_exist)
2214 num_of_diff_profile++;
2215 if (bt_link_info->hid_exist)
2216 num_of_diff_profile++;
2217 if (bt_link_info->pan_exist)
2218 num_of_diff_profile++;
2219 if (bt_link_info->a2dp_exist)
2220 num_of_diff_profile++;
2222 if (num_of_diff_profile == 0) {
2224 if (bt_link_info->acl_busy) {
2225 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2226 "[BTCoex], No-Profile busy\n");
2227 BTC_TRACE(trace_buf);
2228 algorithm = BT_8723D_2ANT_COEX_ALGO_NOPROFILEBUSY;
2230 } else if (num_of_diff_profile == 1) {
2231 if (bt_link_info->sco_exist) {
2232 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2233 "[BTCoex], SCO only\n");
2234 BTC_TRACE(trace_buf);
2235 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2237 if (bt_link_info->hid_exist) {
2238 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2239 "[BTCoex], HID only\n");
2240 BTC_TRACE(trace_buf);
2241 algorithm = BT_8723D_2ANT_COEX_ALGO_HID;
2242 } else if (bt_link_info->a2dp_exist) {
2243 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2244 "[BTCoex], A2DP only\n");
2245 BTC_TRACE(trace_buf);
2246 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DP;
2247 } else if (bt_link_info->pan_exist) {
2249 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2250 "[BTCoex], PAN(HS) only\n");
2251 BTC_TRACE(trace_buf);
2253 BT_8723D_2ANT_COEX_ALGO_PANHS;
2255 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2256 "[BTCoex], PAN(EDR) only\n");
2257 BTC_TRACE(trace_buf);
2259 BT_8723D_2ANT_COEX_ALGO_PANEDR;
2263 } else if (num_of_diff_profile == 2) {
2264 if (bt_link_info->sco_exist) {
2265 if (bt_link_info->hid_exist) {
2266 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2267 "[BTCoex], SCO + HID\n");
2268 BTC_TRACE(trace_buf);
2269 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2270 } else if (bt_link_info->a2dp_exist) {
2271 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2272 "[BTCoex], SCO + A2DP ==> A2DP\n");
2273 BTC_TRACE(trace_buf);
2274 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DP;
2275 } else if (bt_link_info->pan_exist) {
2277 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2278 "[BTCoex], SCO + PAN(HS)\n");
2279 BTC_TRACE(trace_buf);
2280 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2282 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2283 "[BTCoex], SCO + PAN(EDR)\n");
2284 BTC_TRACE(trace_buf);
2286 BT_8723D_2ANT_COEX_ALGO_PANEDR;
2290 if (bt_link_info->hid_exist &&
2291 bt_link_info->a2dp_exist) {
2293 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2294 "[BTCoex], HID + A2DP\n");
2295 BTC_TRACE(trace_buf);
2297 BT_8723D_2ANT_COEX_ALGO_HID_A2DP;
2299 } else if (bt_link_info->hid_exist &&
2300 bt_link_info->pan_exist) {
2302 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2303 "[BTCoex], HID + PAN(HS)\n");
2304 BTC_TRACE(trace_buf);
2305 algorithm = BT_8723D_2ANT_COEX_ALGO_HID;
2307 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2308 "[BTCoex], HID + PAN(EDR)\n");
2309 BTC_TRACE(trace_buf);
2311 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2313 } else if (bt_link_info->pan_exist &&
2314 bt_link_info->a2dp_exist) {
2316 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2317 "[BTCoex], A2DP + PAN(HS)\n");
2318 BTC_TRACE(trace_buf);
2320 BT_8723D_2ANT_COEX_ALGO_A2DP_PANHS;
2322 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2323 "[BTCoex], A2DP + PAN(EDR)\n");
2324 BTC_TRACE(trace_buf);
2326 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2330 } else if (num_of_diff_profile == 3) {
2331 if (bt_link_info->sco_exist) {
2332 if (bt_link_info->hid_exist &&
2333 bt_link_info->a2dp_exist) {
2334 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2335 "[BTCoex], SCO + HID + A2DP ==> HID + A2DP\n");
2336 BTC_TRACE(trace_buf);
2337 algorithm = BT_8723D_2ANT_COEX_ALGO_HID_A2DP;
2338 } else if (bt_link_info->hid_exist &&
2339 bt_link_info->pan_exist) {
2341 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2342 "[BTCoex], SCO + HID + PAN(HS)\n");
2343 BTC_TRACE(trace_buf);
2345 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2347 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2348 "[BTCoex], SCO + HID + PAN(EDR)\n");
2349 BTC_TRACE(trace_buf);
2351 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2353 } else if (bt_link_info->pan_exist &&
2354 bt_link_info->a2dp_exist) {
2356 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2357 "[BTCoex], SCO + A2DP + PAN(HS)\n");
2358 BTC_TRACE(trace_buf);
2360 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2362 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2363 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
2364 BTC_TRACE(trace_buf);
2366 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2370 if (bt_link_info->hid_exist &&
2371 bt_link_info->pan_exist &&
2372 bt_link_info->a2dp_exist) {
2374 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2375 "[BTCoex], HID + A2DP + PAN(HS)\n");
2376 BTC_TRACE(trace_buf);
2378 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2380 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2381 "[BTCoex], HID + A2DP + PAN(EDR)\n");
2382 BTC_TRACE(trace_buf);
2384 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2388 } else if (num_of_diff_profile >= 3) {
2389 if (bt_link_info->sco_exist) {
2390 if (bt_link_info->hid_exist &&
2391 bt_link_info->pan_exist &&
2392 bt_link_info->a2dp_exist) {
2394 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2395 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
2396 BTC_TRACE(trace_buf);
2398 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2400 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2401 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
2402 BTC_TRACE(trace_buf);
2404 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2415 void halbtc8723d2ant_action_coex_all_off(IN struct btc_coexist *btcoexist)
2418 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2421 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2423 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2424 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2427 void halbtc8723d2ant_action_bt_whql_test(IN struct btc_coexist *btcoexist)
2429 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2430 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2432 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2434 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2437 void halbtc8723d2ant_action_bt_hs(IN struct btc_coexist *btcoexist)
2439 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2440 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2441 u8 wifi_rssi_state, bt_rssi_state;
2443 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2444 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2445 u8 wifi_rssi_state2, bt_rssi_state2;
2446 boolean wifi_busy = false, wifi_turbo = false;
2449 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2450 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2451 &coex_sta->scan_ap_num);
2452 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2453 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
2454 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2455 BTC_TRACE(trace_buf);
2458 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2463 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2464 &prewifi_rssi_state, 2,
2465 coex_sta->wifi_coex_thres , 0);
2467 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2468 &prewifi_rssi_state2, 2,
2469 coex_sta->wifi_coex_thres2 , 0);
2471 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2472 coex_sta->bt_coex_thres , 0);
2474 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2475 coex_sta->bt_coex_thres2 , 0);
2477 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2478 BTC_RSSI_HIGH(bt_rssi_state)) {
2480 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2481 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2483 coex_dm->is_switch_to_1dot5_ant = false;
2485 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2487 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2488 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2489 BTC_RSSI_HIGH(bt_rssi_state2)) {
2491 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2492 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2494 coex_dm->is_switch_to_1dot5_ant = false;
2496 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2498 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2503 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2504 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2506 coex_dm->is_switch_to_1dot5_ant = true;
2508 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2510 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2516 void halbtc8723d2ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
2519 boolean wifi_connected = false;
2520 boolean wifi_scan = false, wifi_link = false, wifi_roam = false;
2521 boolean wifi_busy = false;
2522 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2525 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2527 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2530 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
2531 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
2532 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
2534 if ((coex_sta->bt_create_connection) && ((wifi_link) || (wifi_roam)
2535 || (wifi_scan) || (wifi_busy) || (coex_sta->wifi_is_high_pri_task))) {
2537 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2538 "[BTCoex], Wifi link/roam/Scan/busy/hi-pri-task + BT Inq/Page!!\n");
2539 BTC_TRACE(trace_buf);
2541 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2544 if ((bt_link_info->a2dp_exist) && (!bt_link_info->pan_exist))
2545 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2548 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2550 } else if ((!wifi_connected) && (!wifi_scan)) {
2552 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2553 "[BTCoex], Wifi no-link + no-scan + BT Inq/Page!!\n");
2554 BTC_TRACE(trace_buf);
2556 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2558 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2559 } else if (bt_link_info->pan_exist) {
2561 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
2563 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2565 } else if (bt_link_info->a2dp_exist) {
2567 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
2569 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2572 if ((wifi_link) || (wifi_roam) || (wifi_scan) || (wifi_busy)
2573 || (coex_sta->wifi_is_high_pri_task))
2574 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 21);
2576 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2578 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2581 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2582 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2586 void halbtc8723d2ant_action_bt_relink(IN struct btc_coexist *btcoexist)
2588 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
2589 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2591 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2592 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2593 coex_sta->bt_relink_downcount = 2;
2596 void halbtc8723d2ant_action_bt_idle(IN struct btc_coexist *btcoexist)
2598 boolean wifi_busy = false;
2600 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2604 halbtc8723d2ant_coex_table_with_type(btcoexist,
2607 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2608 } else { /* if wl busy */
2610 if (BT_8723D_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2611 coex_dm->bt_status) {
2613 halbtc8723d2ant_coex_table_with_type(btcoexist,
2616 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2619 halbtc8723d2ant_coex_table_with_type(btcoexist,
2621 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2626 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2627 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2633 /* SCO only or SCO+PAN(HS) */
2634 void halbtc8723d2ant_action_sco(IN struct btc_coexist *btcoexist)
2636 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2637 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2638 u8 wifi_rssi_state, bt_rssi_state;
2640 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2641 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2642 u8 wifi_rssi_state2, bt_rssi_state2;
2643 boolean wifi_busy = false;
2646 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2649 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2651 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2652 &prewifi_rssi_state, 2,
2653 coex_sta->wifi_coex_thres , 0);
2655 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2656 &prewifi_rssi_state2, 2,
2657 coex_sta->wifi_coex_thres2 , 0);
2659 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2660 coex_sta->bt_coex_thres , 0);
2662 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2663 coex_sta->bt_coex_thres2 , 0);
2666 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2667 BTC_RSSI_HIGH(bt_rssi_state)) {
2669 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2670 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2672 coex_dm->is_switch_to_1dot5_ant = false;
2674 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2676 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2679 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2680 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2682 coex_dm->is_switch_to_1dot5_ant = false;
2684 if (coex_sta->is_eSCO_mode)
2685 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2686 else /* 2-Ant free run if eSCO mode */
2687 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2689 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
2695 void halbtc8723d2ant_action_hid(IN struct btc_coexist *btcoexist)
2697 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2698 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2699 u8 wifi_rssi_state, bt_rssi_state;
2701 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2702 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2703 u8 wifi_rssi_state2, bt_rssi_state2;
2704 boolean wifi_busy = false;
2708 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2709 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2711 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2712 &prewifi_rssi_state, 2,
2713 coex_sta->wifi_coex_thres , 0);
2715 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2716 &prewifi_rssi_state2, 2,
2717 coex_sta->wifi_coex_thres2 , 0);
2719 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2720 coex_sta->bt_coex_thres , 0);
2722 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2723 coex_sta->bt_coex_thres2 , 0);
2726 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2727 BTC_RSSI_HIGH(bt_rssi_state)) {
2729 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2730 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2732 coex_dm->is_switch_to_1dot5_ant = false;
2734 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2736 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2739 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2740 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2742 coex_dm->is_switch_to_1dot5_ant = false;
2745 if (coex_sta->hid_busy_num >= 2) {
2746 if (wifi_bw == 0) { /* if 11bg mode */
2748 halbtc8723d2ant_coex_table_with_type(btcoexist,
2750 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
2755 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2760 halbtc8723d2ant_coex_table_with_type(btcoexist,
2762 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
2767 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2771 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2773 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2778 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2780 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2787 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2788 void halbtc8723d2ant_action_a2dp(IN struct btc_coexist *btcoexist)
2790 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2791 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2792 u8 wifi_rssi_state, bt_rssi_state;
2794 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2795 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2796 u8 wifi_rssi_state2, bt_rssi_state2;
2797 boolean wifi_busy = false, wifi_turbo = false;
2800 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2801 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2802 &coex_sta->scan_ap_num);
2803 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2804 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
2805 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2806 BTC_TRACE(trace_buf);
2809 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2813 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2814 &prewifi_rssi_state, 2,
2815 coex_sta->wifi_coex_thres , 0);
2817 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2818 &prewifi_rssi_state2, 2,
2819 coex_sta->wifi_coex_thres2 , 0);
2821 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2822 coex_sta->bt_coex_thres , 0);
2824 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2825 coex_sta->bt_coex_thres2 , 0);
2828 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2829 BTC_RSSI_HIGH(bt_rssi_state)) {
2831 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2832 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2834 coex_dm->is_switch_to_1dot5_ant = false;
2836 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2838 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2839 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2840 BTC_RSSI_HIGH(bt_rssi_state2)) {
2842 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2843 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2845 coex_dm->is_switch_to_1dot5_ant = false;
2847 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2850 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2853 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2857 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2858 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2860 coex_dm->is_switch_to_1dot5_ant = true;
2862 if ((coex_sta->bt_relink_downcount != 0)
2865 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2866 "############# [BTCoex], BT Re-Link + A2DP + WL busy\n");
2867 BTC_TRACE(trace_buf);
2869 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2870 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2875 halbtc8723d2ant_coex_table_with_type(btcoexist,
2878 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2882 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2885 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2887 /*halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2896 void halbtc8723d2ant_action_pan_edr(IN struct btc_coexist *btcoexist)
2898 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2899 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2900 u8 wifi_rssi_state, bt_rssi_state;
2902 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2903 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2904 u8 wifi_rssi_state2, bt_rssi_state2;
2905 boolean wifi_busy = false, wifi_turbo = false;
2908 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2909 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2910 &coex_sta->scan_ap_num);
2911 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2912 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
2913 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2914 BTC_TRACE(trace_buf);
2917 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2921 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2922 &prewifi_rssi_state, 2,
2923 coex_sta->wifi_coex_thres , 0);
2925 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2926 &prewifi_rssi_state2, 2,
2927 coex_sta->wifi_coex_thres2 , 0);
2929 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2930 coex_sta->bt_coex_thres , 0);
2932 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2933 coex_sta->bt_coex_thres2 , 0);
2936 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2937 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2939 coex_dm->is_switch_to_1dot5_ant = false;
2941 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2943 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2948 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2949 BTC_RSSI_HIGH(bt_rssi_state)) {
2951 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2952 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2954 coex_dm->is_switch_to_1dot5_ant = false;
2956 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2958 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2959 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2960 BTC_RSSI_HIGH(bt_rssi_state2)) {
2962 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2963 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2965 coex_dm->is_switch_to_1dot5_ant = false;
2967 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2970 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2973 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2977 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2978 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2980 coex_dm->is_switch_to_1dot5_ant = true;
2983 halbtc8723d2ant_coex_table_with_type(btcoexist,
2986 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2990 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2993 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3002 void halbtc8723d2ant_action_hid_a2dp(IN struct btc_coexist *btcoexist)
3004 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3005 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3006 u8 wifi_rssi_state, bt_rssi_state;
3008 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3009 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3010 u8 wifi_rssi_state2, bt_rssi_state2;
3011 boolean wifi_busy = false;
3014 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3016 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3018 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3019 &prewifi_rssi_state, 2,
3020 coex_sta->wifi_coex_thres , 0);
3022 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3023 &prewifi_rssi_state2, 2,
3024 coex_sta->wifi_coex_thres2 , 0);
3026 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3027 coex_sta->bt_coex_thres , 0);
3029 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3030 coex_sta->bt_coex_thres2 , 0);
3033 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3034 BTC_RSSI_HIGH(bt_rssi_state)) {
3036 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3037 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3039 coex_dm->is_switch_to_1dot5_ant = false;
3041 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3042 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3043 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3044 BTC_RSSI_HIGH(bt_rssi_state2)) {
3046 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3047 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3049 coex_dm->is_switch_to_1dot5_ant = false;
3051 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3054 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3057 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3061 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3062 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3064 coex_dm->is_switch_to_1dot5_ant = true;
3066 if ((coex_sta->bt_relink_downcount != 0)
3069 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3070 "############# [BTCoex], BT Re-Link + A2DP + WL busy\n");
3071 BTC_TRACE(trace_buf);
3073 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3074 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
3075 } else if (wifi_busy) {
3076 if (coex_sta->hid_busy_num >= 2) {
3077 halbtc8723d2ant_coex_table_with_type(btcoexist,
3079 if (wifi_bw == 0) /*11bg mode */
3080 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3086 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3091 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3094 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3095 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3099 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3101 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3110 void halbtc8723d2ant_action_a2dp_pan_hs(IN struct btc_coexist *btcoexist)
3112 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3113 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3114 u8 wifi_rssi_state, bt_rssi_state;
3116 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3117 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3118 u8 wifi_rssi_state2, bt_rssi_state2;
3119 boolean wifi_busy = false, wifi_turbo = false;
3122 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3123 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3124 &coex_sta->scan_ap_num);
3125 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3126 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
3127 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3128 BTC_TRACE(trace_buf);
3131 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3136 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3137 &prewifi_rssi_state, 2,
3138 coex_sta->wifi_coex_thres , 0);
3140 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3141 &prewifi_rssi_state2, 2,
3142 coex_sta->wifi_coex_thres2 , 0);
3144 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3145 coex_sta->bt_coex_thres , 0);
3147 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3148 coex_sta->bt_coex_thres2 , 0);
3151 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3152 BTC_RSSI_HIGH(bt_rssi_state)) {
3154 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3155 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3157 coex_dm->is_switch_to_1dot5_ant = false;
3159 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3161 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3162 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3163 BTC_RSSI_HIGH(bt_rssi_state2)) {
3165 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3166 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3168 coex_dm->is_switch_to_1dot5_ant = false;
3170 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3174 if ((coex_sta->a2dp_bit_pool > 40) &&
3175 (coex_sta->a2dp_bit_pool < 255))
3176 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3179 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3182 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3187 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3188 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3190 coex_dm->is_switch_to_1dot5_ant = true;
3193 halbtc8723d2ant_coex_table_with_type(btcoexist,
3196 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3201 if ((coex_sta->a2dp_bit_pool > 40) &&
3202 (coex_sta->a2dp_bit_pool < 255))
3203 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3206 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3209 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3218 void halbtc8723d2ant_action_pan_edr_a2dp(IN struct btc_coexist *btcoexist)
3220 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3221 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3222 u8 wifi_rssi_state, bt_rssi_state;
3224 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3225 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3226 u8 wifi_rssi_state2, bt_rssi_state2;
3227 boolean wifi_busy = false, wifi_turbo = false;
3230 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3231 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3232 &coex_sta->scan_ap_num);
3233 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3234 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
3235 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3236 BTC_TRACE(trace_buf);
3239 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3244 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3245 &prewifi_rssi_state, 2,
3246 coex_sta->wifi_coex_thres , 0);
3248 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3249 &prewifi_rssi_state2, 2,
3250 coex_sta->wifi_coex_thres2 , 0);
3252 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3253 coex_sta->bt_coex_thres , 0);
3255 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3256 coex_sta->bt_coex_thres2 , 0);
3258 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3259 BTC_RSSI_HIGH(bt_rssi_state)) {
3261 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3262 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3264 coex_dm->is_switch_to_1dot5_ant = false;
3266 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3267 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3268 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3269 BTC_RSSI_HIGH(bt_rssi_state2)) {
3271 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3272 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3274 coex_dm->is_switch_to_1dot5_ant = false;
3276 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3280 if (((coex_sta->a2dp_bit_pool > 40) &&
3281 (coex_sta->a2dp_bit_pool < 255)) ||
3282 (!coex_sta->is_A2DP_3M))
3283 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3286 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3289 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3293 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3294 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3296 coex_dm->is_switch_to_1dot5_ant = true;
3299 halbtc8723d2ant_coex_table_with_type(btcoexist,
3302 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3307 if ((coex_sta->a2dp_bit_pool > 40) &&
3308 (coex_sta->a2dp_bit_pool < 255))
3309 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3311 else if (wifi_turbo)
3312 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3315 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3318 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3326 void halbtc8723d2ant_action_pan_edr_hid(IN struct btc_coexist *btcoexist)
3328 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3329 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3330 u8 wifi_rssi_state, bt_rssi_state;
3332 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3333 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3334 u8 wifi_rssi_state2, bt_rssi_state2;
3335 boolean wifi_busy = false;
3338 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3341 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3343 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3344 &prewifi_rssi_state, 2,
3345 coex_sta->wifi_coex_thres , 0);
3347 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3348 &prewifi_rssi_state2, 2,
3349 coex_sta->wifi_coex_thres2 , 0);
3351 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3352 coex_sta->bt_coex_thres , 0);
3354 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3355 coex_sta->bt_coex_thres2 , 0);
3358 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3359 BTC_RSSI_HIGH(bt_rssi_state)) {
3361 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3362 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3364 coex_dm->is_switch_to_1dot5_ant = false;
3366 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3367 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3368 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3369 BTC_RSSI_HIGH(bt_rssi_state2)) {
3371 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3372 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3374 coex_dm->is_switch_to_1dot5_ant = false;
3376 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3379 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3382 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3386 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3387 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3389 coex_dm->is_switch_to_1dot5_ant = true;
3391 if (coex_sta->hid_busy_num >= 2) {
3393 halbtc8723d2ant_coex_table_with_type(btcoexist,
3395 if (wifi_bw == 0) /*11bg mode */
3396 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3402 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3407 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3411 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3414 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3417 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3426 /* HID+A2DP+PAN(EDR) */
3427 void halbtc8723d2ant_action_hid_a2dp_pan_edr(IN struct btc_coexist *btcoexist)
3429 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3430 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3431 u8 wifi_rssi_state, bt_rssi_state;
3433 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3434 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3435 u8 wifi_rssi_state2, bt_rssi_state2;
3436 boolean wifi_busy = false;
3439 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3442 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3444 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3445 &prewifi_rssi_state, 2,
3446 coex_sta->wifi_coex_thres , 0);
3448 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3449 &prewifi_rssi_state2, 2,
3450 coex_sta->wifi_coex_thres2 , 0);
3452 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3453 coex_sta->bt_coex_thres , 0);
3455 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3456 coex_sta->bt_coex_thres2 , 0);
3459 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3460 BTC_RSSI_HIGH(bt_rssi_state)) {
3462 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3463 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3465 coex_dm->is_switch_to_1dot5_ant = false;
3467 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3468 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3469 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3470 BTC_RSSI_HIGH(bt_rssi_state2)) {
3472 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3473 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3475 coex_dm->is_switch_to_1dot5_ant = false;
3477 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3481 if (((coex_sta->a2dp_bit_pool > 40) &&
3482 (coex_sta->a2dp_bit_pool < 255)) ||
3483 (!coex_sta->is_A2DP_3M))
3484 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3487 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3490 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3494 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3495 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3497 coex_dm->is_switch_to_1dot5_ant = true;
3499 if (coex_sta->hid_busy_num >= 2) {
3500 halbtc8723d2ant_coex_table_with_type(btcoexist,
3502 if (wifi_bw == 0) /*11bg mode */
3503 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3509 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3514 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3517 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3521 if ((coex_sta->a2dp_bit_pool > 40) &&
3522 (coex_sta->a2dp_bit_pool < 255))
3523 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3526 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3529 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3537 void halbtc8723d2ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
3539 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3540 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3543 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3545 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3548 void halbtc8723d2ant_action_wifi_linkscan_process(IN struct btc_coexist *btcoexist)
3550 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3552 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
3553 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3555 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3557 if (bt_link_info->pan_exist) {
3559 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
3561 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3563 } else if (bt_link_info->a2dp_exist) {
3565 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
3567 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3570 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 21);
3572 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3577 void halbtc8723d2ant_action_wifi_not_connected(IN struct btc_coexist *btcoexist)
3579 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3582 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3584 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3585 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3588 void halbtc8723d2ant_action_wifi_connected(IN struct btc_coexist *btcoexist)
3590 switch (coex_dm->cur_algorithm) {
3592 case BT_8723D_2ANT_COEX_ALGO_SCO:
3593 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3594 "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
3595 BTC_TRACE(trace_buf);
3596 halbtc8723d2ant_action_sco(btcoexist);
3598 case BT_8723D_2ANT_COEX_ALGO_HID:
3599 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3600 "[BTCoex], Action 2-Ant, algorithm = HID.\n");
3601 BTC_TRACE(trace_buf);
3602 halbtc8723d2ant_action_hid(btcoexist);
3604 case BT_8723D_2ANT_COEX_ALGO_A2DP:
3605 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3606 "[BTCoex], Action 2-Ant, algorithm = A2DP.\n");
3607 BTC_TRACE(trace_buf);
3608 halbtc8723d2ant_action_a2dp(btcoexist);
3610 case BT_8723D_2ANT_COEX_ALGO_A2DP_PANHS:
3611 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3612 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
3613 BTC_TRACE(trace_buf);
3614 halbtc8723d2ant_action_a2dp_pan_hs(btcoexist);
3616 case BT_8723D_2ANT_COEX_ALGO_PANEDR:
3617 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3618 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n");
3619 BTC_TRACE(trace_buf);
3620 halbtc8723d2ant_action_pan_edr(btcoexist);
3622 case BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP:
3623 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3624 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n");
3625 BTC_TRACE(trace_buf);
3626 halbtc8723d2ant_action_pan_edr_a2dp(btcoexist);
3628 case BT_8723D_2ANT_COEX_ALGO_PANEDR_HID:
3629 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3630 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
3631 BTC_TRACE(trace_buf);
3632 halbtc8723d2ant_action_pan_edr_hid(btcoexist);
3634 case BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3635 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3636 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
3637 BTC_TRACE(trace_buf);
3638 halbtc8723d2ant_action_hid_a2dp_pan_edr(
3641 case BT_8723D_2ANT_COEX_ALGO_HID_A2DP:
3642 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3643 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n");
3644 BTC_TRACE(trace_buf);
3645 halbtc8723d2ant_action_hid_a2dp(btcoexist);
3647 case BT_8723D_2ANT_COEX_ALGO_NOPROFILEBUSY:
3648 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3649 "[BTCoex], Action 2-Ant, algorithm = No-Profile busy.\n");
3650 BTC_TRACE(trace_buf);
3651 halbtc8723d2ant_action_bt_idle(btcoexist);
3654 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3655 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3656 BTC_TRACE(trace_buf);
3657 halbtc8723d2ant_action_coex_all_off(btcoexist);
3661 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3666 void halbtc8723d2ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
3669 u32 num_of_wifi_link = 0;
3670 u32 wifi_link_status = 0;
3671 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3672 boolean miracast_plus_bt = false;
3673 boolean scan = false, link = false, roam = false,
3675 wifi_connected = false, wifi_under_5g = false,
3678 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3679 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3680 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3681 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3684 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3685 "[BTCoex], RunCoexistMechanism()===>\n");
3686 BTC_TRACE(trace_buf);
3688 if (btcoexist->manual_control) {
3689 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3690 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3691 BTC_TRACE(trace_buf);
3695 if (btcoexist->stop_coex_dm) {
3696 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3697 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
3698 BTC_TRACE(trace_buf);
3702 if (coex_sta->under_ips) {
3703 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3704 "[BTCoex], wifi is under IPS !!!\n");
3705 BTC_TRACE(trace_buf);
3709 if (!coex_sta->run_time_state) {
3710 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3711 "[BTCoex], return for run_time_state = false !!!\n");
3712 BTC_TRACE(trace_buf);
3716 if (coex_sta->freeze_coexrun_by_btinfo) {
3717 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3718 "[BTCoex], BtInfoNotify(), return for freeze_coexrun_by_btinfo\n");
3719 BTC_TRACE(trace_buf);
3723 if (coex_sta->bt_whck_test) {
3724 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3725 "[BTCoex], BT is under WHCK TEST!!!\n");
3726 BTC_TRACE(trace_buf);
3727 halbtc8723d2ant_action_bt_whql_test(btcoexist);
3731 if (coex_sta->bt_disabled) {
3732 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3733 "[BTCoex], BT is disabled!!!\n");
3734 BTC_TRACE(trace_buf);
3735 halbtc8723d2ant_action_coex_all_off(btcoexist);
3739 if (coex_sta->c2h_bt_inquiry_page) {
3740 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3741 "[BTCoex], BT is under inquiry/page scan !!\n");
3742 BTC_TRACE(trace_buf);
3743 halbtc8723d2ant_action_bt_inquiry(btcoexist);
3747 if (coex_sta->is_setupLink) {
3748 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3749 "[BTCoex], BT is re-link !!!\n");
3750 halbtc8723d2ant_action_bt_relink(btcoexist);
3755 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3757 num_of_wifi_link = wifi_link_status >> 16;
3759 if ((num_of_wifi_link >= 2) ||
3760 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3761 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3762 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3763 num_of_wifi_link, wifi_link_status);
3764 BTC_TRACE(trace_buf);
3766 if (bt_link_info->bt_link_exist)
3767 miracast_plus_bt = true;
3769 miracast_plus_bt = false;
3771 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3774 if (scan || link || roam || under_4way) {
3775 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3776 "[BTCoex], scan = %d, link = %d, roam = %d 4way = %d!!!\n",
3777 scan, link, roam, under_4way);
3778 BTC_TRACE(trace_buf);
3780 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3781 "[BTCoex], wifi is under linkscan process + Multi-Port !!\n");
3782 BTC_TRACE(trace_buf);
3784 halbtc8723d2ant_action_wifi_linkscan_process(btcoexist);
3787 halbtc8723d2ant_action_wifi_multi_port(btcoexist);
3791 miracast_plus_bt = false;
3792 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3796 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3799 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3800 "############# [BTCoex], BT Is hs\n");
3801 BTC_TRACE(trace_buf);
3802 halbtc8723d2ant_action_bt_hs(btcoexist);
3806 if ((BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3807 coex_dm->bt_status) ||
3808 (BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE ==
3809 coex_dm->bt_status)) {
3811 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3812 "[BTCoex], Action 2-Ant, bt idle!!.\n");
3813 BTC_TRACE(trace_buf);
3815 halbtc8723d2ant_action_bt_idle(btcoexist);
3819 algorithm = halbtc8723d2ant_action_algorithm(btcoexist);
3820 coex_dm->cur_algorithm = algorithm;
3821 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Algorithm = %d\n",
3822 coex_dm->cur_algorithm);
3823 BTC_TRACE(trace_buf);
3825 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3828 if (scan || link || roam || under_4way) {
3829 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3830 "[BTCoex], WiFi is under Link Process !!\n");
3831 BTC_TRACE(trace_buf);
3832 halbtc8723d2ant_action_wifi_linkscan_process(btcoexist);
3833 } else if (wifi_connected) {
3835 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3836 "[BTCoex], Action 2-Ant, wifi connected!!.\n");
3837 BTC_TRACE(trace_buf);
3838 halbtc8723d2ant_action_wifi_connected(btcoexist);
3842 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3843 "[BTCoex], Action 2-Ant, wifi not-connected!!.\n");
3844 BTC_TRACE(trace_buf);
3845 halbtc8723d2ant_action_wifi_not_connected(btcoexist);
3850 void halbtc8723d2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
3852 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3853 "[BTCoex], Coex Mechanism Init!!\n");
3854 BTC_TRACE(trace_buf);
3856 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3857 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3860 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, false);
3862 coex_sta->pop_event_cnt = 0;
3863 coex_sta->cnt_RemoteNameReq = 0;
3864 coex_sta->cnt_ReInit = 0;
3865 coex_sta->cnt_setupLink = 0;
3866 coex_sta->cnt_IgnWlanAct = 0;
3867 coex_sta->cnt_Page = 0;
3869 halbtc8723d2ant_query_bt_info(btcoexist);
3873 void halbtc8723d2ant_init_hw_config(IN struct btc_coexist *btcoexist,
3874 IN boolean wifi_only)
3876 u8 u8tmp0 = 0, u8tmp1 = 0;
3878 u32 u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
3883 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3884 "[BTCoex], 2Ant Init HW Config!!\n");
3885 BTC_TRACE(trace_buf);
3887 #if BT_8723D_2ANT_COEX_DBG
3888 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
3890 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
3892 u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
3893 u8tmp1 = btcoexist->btc_read_1byte(btcoexist, 0x73);
3894 u8tmp0 = btcoexist->btc_read_1byte(btcoexist, 0x67);
3896 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3897 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(Before init_hw_config)\n",
3898 u8tmp0, u16tmp1, u8tmp1);
3899 BTC_TRACE(trace_buf);
3901 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3902 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x (Before init_hw_config)\n",
3904 BTC_TRACE(trace_buf);
3908 coex_sta->bt_coex_supported_feature = 0;
3909 coex_sta->bt_coex_supported_version = 0;
3910 coex_sta->bt_ble_scan_type = 0;
3911 coex_sta->bt_ble_scan_para[0] = 0;
3912 coex_sta->bt_ble_scan_para[1] = 0;
3913 coex_sta->bt_ble_scan_para[2] = 0;
3914 coex_sta->bt_reg_vendor_ac = 0xffff;
3915 coex_sta->bt_reg_vendor_ae = 0xffff;
3916 coex_sta->gnt_error_cnt = 0;
3917 coex_sta->bt_relink_downcount = 0;
3919 for (i = 0; i <= 9; i++)
3920 coex_sta->bt_afh_map[i] = 0;
3923 btcoexist->btc_get(btcoexist, BTC_GET_U4_VENDOR, &vendor);
3924 if (vendor == BTC_VENDOR_LENOVO)
3925 coex_dm->switch_thres_offset = 0;
3927 coex_dm->switch_thres_offset = 20;
3929 /* 0xf0[15:12] --> Chip Cut information */
3930 coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
3933 coex_sta->dis_ver_info_cnt = 0;
3935 /* default isolation = 15dB */
3936 coex_sta->isolation_btween_wb = BT_8723D_2ANT_DEFAULT_ISOLATION;
3937 halbtc8723d2ant_coex_switch_threshold(btcoexist,
3938 coex_sta->isolation_btween_wb);
3940 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
3941 0x1); /* enable TBTT nterrupt */
3943 /* BT report packet sample rate */
3944 btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
3946 /* Init 0x778 = 0x1 for 2-Ant */
3947 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
3949 /* Enable PTA (3-wire function form BT side) */
3950 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3951 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x41, 0x02, 0x1);
3953 /* Enable PTA (tx/rx signal form WiFi side) */
3954 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4c6, 0x10, 0x1);
3956 halbtc8723d2ant_enable_gnt_to_gpio(btcoexist, true);
3959 /* check if WL firmware download ok */
3960 if (btcoexist->btc_read_1byte(btcoexist, 0x80) == 0xc6)
3961 halbtc8723d2ant_post_state_to_bt(btcoexist,
3962 BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
3965 /* Enable counter statistics */
3966 btcoexist->btc_write_1byte(btcoexist, 0x76e,
3967 0x4); /* 0x76e[3] =1, WLAN_Act control by PTA */
3969 /* WLAN_Tx by GNT_WL 0x950[29] = 0 */
3970 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x20, 0x0);
3972 halbtc8723d2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3974 halbtc8723d2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
3976 psd_scan->ant_det_is_ant_det_available = true;
3979 coex_sta->concurrent_rx_mode_on = false;
3981 /* Set Antenna Path */
3982 halbtc8723d2ant_set_ant_path(btcoexist,
3985 BT_8723D_2ANT_PHASE_WLANONLY_INIT);
3987 btcoexist->stop_coex_dm = true;
3989 /*Set BT polluted packet on for Tx rate adaptive not including Tx retry break by PTA, 0x45c[19] =1 */
3990 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x45e, 0x8, 0x1);
3992 coex_sta->concurrent_rx_mode_on = true;
3993 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x2, 0x1); */
3995 /* RF 0x1[0] = 0->Set GNT_WL_RF_Rx always = 1 for con-current Rx */
3996 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0x1, 0x0);
3999 halbtc8723d2ant_set_ant_path(btcoexist,
4002 BT_8723D_2ANT_PHASE_COEX_INIT);
4004 btcoexist->stop_coex_dm = false;
4010 u32 halbtc8723d2ant_psd_log2base(IN struct btc_coexist *btcoexist, IN u32 val)
4013 u32 tmp, tmp2, val_integerd_b = 0, tindex, shiftcount = 0;
4014 u32 result, val_fractiond_b = 0, table_fraction[21] = {0, 432, 332, 274, 232, 200,
4015 174, 151, 132, 115, 100, 86, 74, 62, 51, 42,
4034 val_integerd_b = shiftcount + 1;
4037 for (j = 1; j <= val_integerd_b; j++)
4040 tmp = (val * 100) / tmp2;
4046 val_fractiond_b = table_fraction[tindex];
4048 result = val_integerd_b * 100 - val_fractiond_b;
4055 void halbtc8723d2ant_psd_show_antenna_detect_result(IN struct btc_coexist
4058 u8 *cli_buf = btcoexist->cli_buf;
4059 struct btc_board_info *board_info = &btcoexist->board_info;
4061 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4062 "\r\n============[Antenna Detection info] ============\n");
4065 if (psd_scan->ant_det_result == 12) { /* Get Ant Det from BT */
4067 if (board_info->btdm_ant_num_by_ant_det == 1)
4068 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4069 "\r\n %-35s = %s (%d~%d)",
4070 "Ant Det Result", "1-Antenna",
4071 BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT,
4072 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION);
4075 if (psd_scan->ant_det_psd_scan_peak_val >
4076 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
4078 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4079 "\r\n %-35s = %s (>%d)",
4080 "Ant Det Result", "2-Antenna (Bad-Isolation)",
4081 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4083 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4084 "\r\n %-35s = %s (%d~%d)",
4085 "Ant Det Result", "2-Antenna (Good-Isolation)",
4086 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4087 + psd_scan->ant_det_thres_offset,
4088 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4091 } else if (psd_scan->ant_det_result == 1)
4092 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (>%d)",
4093 "Ant Det Result", "2-Antenna (Bad-Isolation)",
4094 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4095 else if (psd_scan->ant_det_result == 2)
4096 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
4097 "Ant Det Result", "2-Antenna (Good-Isolation)",
4098 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4099 + psd_scan->ant_det_thres_offset,
4100 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4102 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
4103 "Ant Det Result", "1-Antenna",
4104 BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT,
4105 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4106 + psd_scan->ant_det_thres_offset);
4110 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s ",
4111 "Antenna Detection Finish",
4112 (board_info->btdm_ant_det_finish
4116 switch (psd_scan->ant_det_result) {
4118 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4119 "(BT is not available)");
4121 case 1: /* 2-Ant bad-isolation */
4122 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4123 "(BT is available)");
4125 case 2: /* 2-Ant good-isolation */
4126 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4127 "(BT is available)");
4130 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4131 "(BT is available)");
4134 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4135 "(Uncertainty result)");
4138 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "(Pre-Scan fai)");
4141 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4142 "(WiFi is Scanning)");
4145 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4146 "(BT is not idle)");
4149 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4150 "(Abort by WiFi Scanning)");
4153 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4154 "(Antenna Init is not ready)");
4157 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4158 "(BT is Inquiry or page)");
4161 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4162 "(BT is Disabled)");
4164 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4165 "(BT is available, result from BT");
4170 if (psd_scan->ant_det_result == 12) {
4171 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
4172 "PSD Scan Peak Value",
4173 psd_scan->ant_det_psd_scan_peak_val / 100);
4178 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4179 "Ant Detect Total Count", psd_scan->ant_det_try_count);
4182 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4183 "Ant Detect Fail Count", psd_scan->ant_det_fail_count);
4186 if ((!board_info->btdm_ant_det_finish) &&
4187 (psd_scan->ant_det_result != 5))
4190 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT Response",
4191 (psd_scan->ant_det_result ? "ok" : "fail"));
4194 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ms", "BT Tx Time",
4195 psd_scan->ant_det_bt_tx_time);
4198 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d", "BT Tx Ch",
4199 psd_scan->ant_det_bt_le_channel);
4202 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
4203 "WiFi PSD Cent-Ch/Offset/Span",
4204 psd_scan->real_cent_freq, psd_scan->real_offset,
4205 psd_scan->real_span);
4208 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
4209 "PSD Pre-Scan Peak Value",
4210 psd_scan->ant_det_pre_psdscan_peak_val / 100);
4213 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (<= %d)",
4214 "PSD Pre-Scan result",
4215 (psd_scan->ant_det_result != 5 ? "ok" : "fail"),
4216 BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
4217 + psd_scan->ant_det_thres_offset);
4220 if (psd_scan->ant_det_result == 5)
4223 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s dB",
4224 "PSD Scan Peak Value", psd_scan->ant_det_peak_val);
4227 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s MHz",
4228 "PSD Scan Peak Freq", psd_scan->ant_det_peak_freq);
4232 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "TFBGA Package",
4233 (board_info->tfbga_package) ? "Yes" : "No");
4236 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4237 "PSD Threshold Offset", psd_scan->ant_det_thres_offset);
4242 void halbtc8723d2ant_psd_showdata(IN struct btc_coexist *btcoexist)
4244 u8 *cli_buf = btcoexist->cli_buf;
4245 u32 delta_freq_per_point;
4246 u32 freq, freq1, freq2, n = 0, i = 0, j = 0, m = 0, psd_rep1, psd_rep2;
4248 if (psd_scan->ant_det_result == 12)
4251 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4252 "\r\n\n============[PSD info] (%d)============\n",
4253 psd_scan->psd_gen_count);
4256 if (psd_scan->psd_gen_count == 0) {
4257 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n No data !!\n");
4262 if (psd_scan->psd_point == 0)
4263 delta_freq_per_point = 0;
4265 delta_freq_per_point = psd_scan->psd_band_width /
4266 psd_scan->psd_point;
4268 /* if (psd_scan->is_psd_show_max_only) */
4270 psd_rep1 = psd_scan->psd_max_value / 100;
4271 psd_rep2 = psd_scan->psd_max_value - psd_rep1 * 100;
4273 freq = ((psd_scan->real_cent_freq - 20) * 1000000 +
4274 psd_scan->psd_max_value_point * delta_freq_per_point);
4275 freq1 = freq / 1000000;
4276 freq2 = freq / 1000 - freq1 * 1000;
4279 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4280 "\r\n Freq = %d.0%d MHz",
4283 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4284 "\r\n Freq = %d.%d MHz",
4288 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4289 ", Value = %d.0%d dB, (%d)\n",
4290 psd_rep1, psd_rep2, psd_scan->psd_max_value);
4292 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4293 ", Value = %d.%d dB, (%d)\n",
4294 psd_rep1, psd_rep2, psd_scan->psd_max_value);
4298 m = psd_scan->psd_start_point;
4299 n = psd_scan->psd_start_point;
4305 freq = ((psd_scan->real_cent_freq - 20) *
4307 delta_freq_per_point);
4308 freq1 = freq / 1000000;
4309 freq2 = freq / 1000 - freq1 * 1000;
4317 else if (freq2 < 100)
4320 "\r\n Freq%6d.0%2d",
4329 } else if ((i % 8 == 0) ||
4330 (m == psd_scan->psd_stop_point)) {
4334 "%6d.000\n", freq1);
4335 else if (freq2 < 100)
4338 "%6d.0%2d\n", freq1,
4350 else if (freq2 < 100)
4366 } while ((i <= 8) && (m <= psd_scan->psd_stop_point));
4370 psd_rep1 = psd_scan->psd_report_max_hold[n] /
4372 psd_rep2 = psd_scan->psd_report_max_hold[n] -
4389 } else if ((j % 8 == 0) ||
4390 (n == psd_scan->psd_stop_point)) {
4394 "%7d.0%d\n", psd_rep1,
4399 "%7d.%d\n", psd_rep1,
4405 "%7d.0%d", psd_rep1,
4418 } while ((j <= 8) && (n <= psd_scan->psd_stop_point));
4420 if ((m > psd_scan->psd_stop_point) ||
4421 (n > psd_scan->psd_stop_point))
4434 #ifdef PLATFORM_WINDOWS
4435 #pragma optimize("", off)
4437 void halbtc8723d2ant_psd_maxholddata(IN struct btc_coexist *btcoexist,
4441 u32 loop_i_max = 0, loop_val_max = 0;
4443 if (gen_count == 1) {
4444 memcpy(psd_scan->psd_report_max_hold,
4445 psd_scan->psd_report,
4446 BT_8723D_2ANT_ANTDET_PSD_POINTS * sizeof(u32));
4449 for (i = psd_scan->psd_start_point;
4450 i <= psd_scan->psd_stop_point; i++) {
4452 /* update max-hold value at each freq point */
4453 if (psd_scan->psd_report[i] > psd_scan->psd_report_max_hold[i])
4454 psd_scan->psd_report_max_hold[i] =
4455 psd_scan->psd_report[i];
4457 /* search the max value in this seep */
4458 if (psd_scan->psd_report[i] > loop_val_max) {
4459 loop_val_max = psd_scan->psd_report[i];
4464 if (gen_count <= BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT)
4465 psd_scan->psd_loop_max_value[gen_count - 1] = loop_val_max;
4470 #ifdef PLATFORM_WINDOWS
4471 #pragma optimize("", off)
4473 u32 halbtc8723d2ant_psd_getdata(IN struct btc_coexist *btcoexist, IN u32 point)
4475 /* reg 0x808[9:0]: FFT data x */
4476 /* reg 0x808[22]: 0-->1 to get 1 FFT data y */
4477 /* reg 0x8b4[15:0]: FFT data y report */
4479 u32 val = 0, psd_report = 0;
4482 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4487 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4490 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4493 if (k++ > BT_8723D_2ANT_ANTDET_SWEEPPOINT_DELAY)
4497 val = btcoexist->btc_read_4byte(btcoexist, 0x8b4);
4499 psd_report = val & 0x0000ffff;
4504 #ifdef PLATFORM_WINDOWS
4505 #pragma optimize("", off)
4507 boolean halbtc8723d2ant_psd_sweep_point(IN struct btc_coexist *btcoexist,
4508 IN u32 cent_freq, IN s32 offset, IN u32 span, IN u32 points,
4509 IN u32 avgnum, IN u32 loopcnt)
4511 u32 i = 0, val = 0, n = 0, k = 0, j, point_index = 0;
4512 u32 points1 = 0, psd_report = 0;
4513 u32 start_p = 0, stop_p = 0, delta_freq_per_point = 156250;
4514 u32 psd_center_freq = 20 * 10 ^ 6;
4515 boolean outloop = false, scan , roam, is_sweep_ok = true;
4517 u32 tmp = 0, u32tmp1 = 0;
4518 u32 wifi_original_channel = 1;
4519 u32 psd_sum = 0, avg_cnt = 0;
4520 u32 i_max = 0, val_max = 0, val_max2 = 0;
4522 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4523 "xxxxxxxxxxxxxxxx PSD Sweep Start!!\n");
4524 BTC_TRACE(trace_buf);
4528 case 0: /* Get PSD parameters */
4531 psd_scan->psd_band_width = 40 * 1000000;
4532 psd_scan->psd_point = points;
4533 psd_scan->psd_start_base = points / 2;
4534 psd_scan->psd_avg_num = avgnum;
4535 psd_scan->real_cent_freq = cent_freq;
4536 psd_scan->real_offset = offset;
4537 psd_scan->real_span = span;
4540 points1 = psd_scan->psd_point;
4541 delta_freq_per_point = psd_scan->psd_band_width /
4542 psd_scan->psd_point;
4544 /* PSD point setup */
4545 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4548 switch (psd_scan->psd_point) {
4564 switch (psd_scan->psd_avg_num) {
4579 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4583 case 1: /* calculate the PSD point index from freq/offset/span */
4584 psd_center_freq = psd_scan->psd_band_width / 2 +
4587 start_p = psd_scan->psd_start_base + (psd_center_freq -
4588 span * (1000000) / 2) / delta_freq_per_point;
4589 psd_scan->psd_start_point = start_p -
4590 psd_scan->psd_start_base;
4592 stop_p = psd_scan->psd_start_base + (psd_center_freq +
4593 span * (1000000) / 2) / delta_freq_per_point;
4594 psd_scan->psd_stop_point = stop_p -
4595 psd_scan->psd_start_base - 1;
4599 case 2: /* set RF channel/BW/Mode */
4601 /* set 3-wire off */
4602 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
4604 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
4607 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
4609 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
4612 btcoexist->btc_write_1byte(btcoexist, 0x522, 0x6f);
4614 /* store WiFi original channel */
4615 wifi_original_channel = btcoexist->btc_get_rf_reg(
4616 btcoexist, BTC_RF_A, 0x18, 0x3ff);
4618 /* Set RF channel */
4619 if (cent_freq == 2484)
4620 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
4623 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
4624 0x18, 0x3ff, (cent_freq - 2412) / 5 +
4625 1); /* WiFi TRx Mask on */
4627 /* save original RCK value */
4628 u32tmp1 = btcoexist->btc_get_rf_reg(
4629 btcoexist, BTC_RF_A, 0x1d, 0xfffff);
4631 /* Enter debug mode */
4632 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xde,
4635 /* Set RF Rx filter corner */
4636 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1d,
4640 /* Set RF mode = Rx, RF Gain = 0x320a0 */
4641 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x0,
4645 if (k++ > BT_8723D_2ANT_ANTDET_SWEEPPOINT_DELAY)
4651 psd_scan->psd_gen_count = 0;
4652 for (j = 1; j <= loopcnt; j++) {
4654 btcoexist->btc_get(btcoexist,
4655 BTC_GET_BL_WIFI_SCAN, &scan);
4656 btcoexist->btc_get(btcoexist,
4657 BTC_GET_BL_WIFI_ROAM, &roam);
4660 is_sweep_ok = false;
4663 memset(psd_scan->psd_report, 0,
4664 psd_scan->psd_point * sizeof(u32));
4665 start_p = psd_scan->psd_start_point +
4666 psd_scan->psd_start_base;
4667 stop_p = psd_scan->psd_stop_point +
4668 psd_scan->psd_start_base + 1;
4673 while (i < stop_p) {
4676 halbtc8723d2ant_psd_getdata(
4677 btcoexist, i - points1);
4680 halbtc8723d2ant_psd_getdata(
4683 if (psd_report == 0)
4686 /* tmp = 20*log10((double)psd_report); */
4687 /* 20*log2(x)/log2(10), log2Base return theresult of the psd_report*100 */
4688 tmp = 6 * halbtc8723d2ant_psd_log2base(
4689 btcoexist, psd_report);
4691 n = i - psd_scan->psd_start_base;
4692 psd_scan->psd_report[n] = tmp;
4694 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4695 "Point=%d, psd_dB_data = %d\n",
4696 i, psd_scan->psd_report[n]);
4697 BTC_TRACE(trace_buf);
4703 halbtc8723d2ant_psd_maxholddata(btcoexist, j);
4705 psd_scan->psd_gen_count = j;
4707 /*Accumulate Max PSD value in this loop if the value > threshold */
4708 if (psd_scan->psd_loop_max_value[j - 1] >=
4711 psd_scan->psd_loop_max_value[j -
4716 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4717 "Loop=%d, Max_dB_data = %d\n",
4718 j, psd_scan->psd_loop_max_value[j
4720 BTC_TRACE(trace_buf);
4724 if (loopcnt == BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT) {
4726 /* search the Max Value between each-freq-point-max-hold value of all sweep*/
4728 i <= BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT;
4733 val_max = psd_scan->psd_loop_max_value[i
4736 psd_scan->psd_loop_max_value[i
4739 psd_scan->psd_loop_max_value[i -
4743 val_max = psd_scan->psd_loop_max_value[i
4746 psd_scan->psd_loop_max_value[i -
4749 psd_scan->psd_loop_max_value[i
4752 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4753 "i = %d, val_hold= %d, val_max = %d, val_max2 = %d\n",
4754 i, psd_scan->psd_loop_max_value[i
4758 BTC_TRACE(trace_buf);
4761 psd_scan->psd_max_value_point = i_max;
4762 psd_scan->psd_max_value = val_max;
4763 psd_scan->psd_max_value2 = val_max2;
4765 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4766 "val_max = %d, val_max2 = %d\n",
4767 psd_scan->psd_max_value,
4768 psd_scan->psd_max_value2);
4769 BTC_TRACE(trace_buf);
4773 psd_scan->psd_avg_value = (psd_sum / avg_cnt);
4774 if ((psd_sum % avg_cnt) >= (avg_cnt / 2))
4775 psd_scan->psd_avg_value++;
4777 psd_scan->psd_avg_value = 0;
4779 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4780 "AvgLoop=%d, Avg_dB_data = %d\n",
4781 avg_cnt, psd_scan->psd_avg_value);
4782 BTC_TRACE(trace_buf);
4786 case 99: /* error */
4790 case 100: /* recovery */
4793 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
4795 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
4798 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
4800 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
4803 btcoexist->btc_write_1byte(btcoexist, 0x522, 0x0);
4806 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4808 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4810 /* restore RF Rx filter corner */
4811 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1d,
4814 /* Exit debug mode */
4815 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xde,
4818 /* restore WiFi original channel */
4819 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x18,
4820 0x3ff, wifi_original_channel);
4829 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4830 "xxxxxxxxxxxxxxxx PSD Sweep Stop!!\n");
4831 BTC_TRACE(trace_buf);
4836 #ifdef PLATFORM_WINDOWS
4837 #pragma optimize("", off)
4839 boolean halbtc8723d2ant_psd_antenna_detection(IN struct btc_coexist
4843 u32 wlpsd_cent_freq = 2484, wlpsd_span = 2;
4844 s32 wlpsd_offset = -4;
4845 u32 bt_tx_time, bt_le_channel;
4846 u8 bt_le_ch[13] = {3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 33};
4848 u8 h2c_parameter[3] = {0}, u8tmpa, u8tmpb;
4851 boolean outloop = false, bt_resp = false, ant_det_finish = false;
4852 u32 freq, freq1, freq2, psd_rep1, psd_rep2, delta_freq_per_point,
4853 u32tmp, u32tmp0, u32tmp1, u32tmp2 ;
4854 struct btc_board_info *board_info = &btcoexist->board_info;
4856 memset(psd_scan->ant_det_peak_val, 0, 16 * sizeof(u8));
4857 memset(psd_scan->ant_det_peak_freq, 0, 16 * sizeof(u8));
4859 psd_scan->ant_det_bt_tx_time =
4860 BT_8723D_2ANT_ANTDET_BTTXTIME; /* 0.42ms*50 = 20ms (0.42ms = 1 PSD sweep) */
4861 psd_scan->ant_det_bt_le_channel = BT_8723D_2ANT_ANTDET_BTTXCHANNEL;
4863 bt_tx_time = psd_scan->ant_det_bt_tx_time;
4864 bt_le_channel = psd_scan->ant_det_bt_le_channel;
4866 if (board_info->tfbga_package) /* for TFBGA */
4867 psd_scan->ant_det_thres_offset = 5;
4869 psd_scan->ant_det_thres_offset = 0;
4874 if (bt_le_channel == 39)
4875 wlpsd_cent_freq = 2484;
4877 for (i = 1; i <= 13; i++) {
4878 if (bt_le_ch[i - 1] ==
4880 wlpsd_cent_freq = 2412
4888 BTC_SPRINTF(trace_buf,
4890 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort!!, Invalid LE channel = %d\n ",
4892 BTC_TRACE(trace_buf);
4898 wlpsd_sweep_count = bt_tx_time * 238 /
4899 100; /* bt_tx_time/0.42 */
4900 wlpsd_sweep_count = wlpsd_sweep_count / 5;
4902 if (wlpsd_sweep_count % 5 != 0)
4903 wlpsd_sweep_count = (wlpsd_sweep_count /
4906 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4907 "xxxxxxxxxxxxxxxx AntennaDetect(), BT_LETxTime=%d, BT_LECh = %d\n",
4908 bt_tx_time, bt_le_channel);
4909 BTC_TRACE(trace_buf);
4910 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4911 "xxxxxxxxxxxxxxxx AntennaDetect(), wlpsd_cent_freq=%d, wlpsd_offset = %d, wlpsd_span = %d, wlpsd_sweep_count = %d\n",
4915 BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT);
4916 BTC_TRACE(trace_buf);
4920 case 1: /* stop coex DM & set antenna path */
4922 btcoexist->stop_coex_dm = true;
4924 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4925 "xxxxxxxxxxxxxxxx AntennaDetect(), Stop Coex DM!!\n");
4926 BTC_TRACE(trace_buf);
4929 halbtc8723d2ant_ps_tdma(btcoexist, FORCE_EXEC,
4932 /* Set coex table */
4933 halbtc8723d2ant_coex_table_with_type(btcoexist,
4936 if (board_info->btdm_ant_pos ==
4937 BTC_ANTENNA_AT_MAIN_PORT) {
4938 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4939 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Main Port\n");
4940 BTC_TRACE(trace_buf);
4942 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4943 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Aux Port\n");
4944 BTC_TRACE(trace_buf);
4947 /* Set Antenna path, switch WiFi to un-certain antenna port */
4948 /* Set Antenna Path, both GNT_WL/GNT_BT = 1, and control by SW */
4949 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
4951 BT_8723D_2ANT_PHASE_ANTENNA_DET);
4953 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4954 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to BT!!\n");
4955 BTC_TRACE(trace_buf);
4957 /* Set AFH mask on at WiFi channel 2472MHz +/- 10MHz */
4958 h2c_parameter[0] = 0x1;
4959 h2c_parameter[1] = 0xd;
4960 h2c_parameter[2] = 0x14;
4962 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4963 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
4966 BTC_TRACE(trace_buf);
4968 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
4971 u32tmp = btcoexist->btc_read_2byte(btcoexist, 0x948);
4972 u32tmp0 = btcoexist->btc_read_4byte(btcoexist, 0x70);
4973 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(
4975 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(
4978 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4979 "[BTCoex], ********** 0x948 = 0x%x, 0x70 = 0x%x, 0x38= 0x%x, 0x54= 0x%x (Before Ant Det)\n",
4980 u32tmp, u32tmp0, u32tmp1, u32tmp2);
4981 BTC_TRACE(trace_buf);
4985 case 2: /* Pre-sweep background psd */
4986 if (!halbtc8723d2ant_psd_sweep_point(btcoexist,
4987 wlpsd_cent_freq, wlpsd_offset, wlpsd_span,
4988 BT_8723D_2ANT_ANTDET_PSD_POINTS,
4989 BT_8723D_2ANT_ANTDET_PSD_AVGNUM, 3)) {
4990 ant_det_finish = false;
4991 board_info->btdm_ant_num_by_ant_det = 1;
4992 psd_scan->ant_det_result = 8;
4997 psd_scan->ant_det_pre_psdscan_peak_val =
4998 psd_scan->psd_max_value;
5000 if (psd_scan->ant_det_pre_psdscan_peak_val >
5001 (BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
5002 + psd_scan->ant_det_thres_offset) * 100) {
5003 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5004 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort Antenna Detection!! becaus background = %d > thres (%d)\n",
5005 psd_scan->ant_det_pre_psdscan_peak_val /
5007 BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
5008 + psd_scan->ant_det_thres_offset);
5009 BTC_TRACE(trace_buf);
5010 ant_det_finish = false;
5011 board_info->btdm_ant_num_by_ant_det = 1;
5012 psd_scan->ant_det_result = 5;
5015 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5016 "xxxxxxxxxxxxxxxx AntennaDetect(), Start Antenna Detection!! becaus background = %d <= thres (%d)\n",
5017 psd_scan->ant_det_pre_psdscan_peak_val /
5019 BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
5020 + psd_scan->ant_det_thres_offset);
5021 BTC_TRACE(trace_buf);
5026 bt_resp = btcoexist->btc_set_bt_ant_detection(
5027 btcoexist, (u8)(bt_tx_time & 0xff),
5028 (u8)(bt_le_channel & 0xff));
5030 /* Sync WL Rx PSD with BT Tx time because H2C->Mailbox delay */
5033 if (!halbtc8723d2ant_psd_sweep_point(btcoexist,
5034 wlpsd_cent_freq, wlpsd_offset,
5036 BT_8723D_2ANT_ANTDET_PSD_POINTS,
5037 BT_8723D_2ANT_ANTDET_PSD_AVGNUM,
5038 BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT)) {
5039 ant_det_finish = false;
5040 board_info->btdm_ant_num_by_ant_det = 1;
5041 psd_scan->ant_det_result = 8;
5047 psd_scan->ant_det_psd_scan_peak_val =
5048 psd_scan->psd_max_value;
5051 psd_scan->ant_det_psd_scan_peak_val =
5052 ((psd_scan->psd_max_value - psd_scan->psd_avg_value) <
5054 psd_scan->psd_max_value : ((
5055 psd_scan->psd_max_value -
5056 psd_scan->psd_max_value2 <= 300) ?
5057 psd_scan->psd_avg_value :
5058 psd_scan->psd_max_value2);
5060 psd_scan->ant_det_psd_scan_peak_freq =
5061 psd_scan->psd_max_value_point;
5066 if (psd_scan->psd_point == 0)
5067 delta_freq_per_point = 0;
5069 delta_freq_per_point =
5070 psd_scan->psd_band_width /
5071 psd_scan->psd_point;
5073 psd_rep1 = psd_scan->ant_det_psd_scan_peak_val / 100;
5074 psd_rep2 = psd_scan->ant_det_psd_scan_peak_val -
5078 freq = ((psd_scan->real_cent_freq - 20) *
5079 1000000 + psd_scan->psd_max_value_point
5080 * delta_freq_per_point);
5081 freq1 = freq / 1000000;
5082 freq2 = freq / 1000 - freq1 * 1000;
5085 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5086 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.0%d MHz",
5088 BTC_TRACE(trace_buf);
5089 CL_SPRINTF(psd_scan->ant_det_peak_freq,
5090 BT_8723D_2ANT_ANTDET_BUF_LEN,
5091 "%d.0%d", freq1, freq2);
5093 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5094 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.%d MHz",
5096 BTC_TRACE(trace_buf);
5097 CL_SPRINTF(psd_scan->ant_det_peak_freq,
5098 BT_8723D_2ANT_ANTDET_BUF_LEN,
5099 "%d.%d", freq1, freq2);
5102 if (psd_rep2 < 10) {
5103 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5104 ", Value = %d.0%d dB\n",
5105 psd_rep1, psd_rep2);
5106 BTC_TRACE(trace_buf);
5107 CL_SPRINTF(psd_scan->ant_det_peak_val,
5108 BT_8723D_2ANT_ANTDET_BUF_LEN,
5109 "%d.0%d", psd_rep1, psd_rep2);
5111 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5112 ", Value = %d.%d dB\n",
5113 psd_rep1, psd_rep2);
5114 BTC_TRACE(trace_buf);
5115 CL_SPRINTF(psd_scan->ant_det_peak_val,
5116 BT_8723D_2ANT_ANTDET_BUF_LEN,
5117 "%d.%d", psd_rep1, psd_rep2);
5120 psd_scan->ant_det_is_btreply_available = true;
5122 if (bt_resp == false) {
5123 psd_scan->ant_det_is_btreply_available =
5125 psd_scan->ant_det_result = 0;
5126 ant_det_finish = false;
5127 board_info->btdm_ant_num_by_ant_det = 1;
5128 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5129 "xxxxxxxxxxxxxxxx AntennaDetect(), BT Response = Fail\n ");
5130 BTC_TRACE(trace_buf);
5131 } else if (psd_scan->ant_det_psd_scan_peak_val >
5132 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
5134 psd_scan->ant_det_result = 1;
5135 ant_det_finish = true;
5136 board_info->btdm_ant_num_by_ant_det = 2;
5137 coex_sta->isolation_btween_wb = (u8)(85 -
5138 psd_scan->ant_det_psd_scan_peak_val /
5140 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5141 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Bad-Isolation!!\n");
5142 BTC_TRACE(trace_buf);
5143 } else if (psd_scan->ant_det_psd_scan_peak_val >
5144 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
5145 + psd_scan->ant_det_thres_offset) * 100) {
5146 psd_scan->ant_det_result = 2;
5147 ant_det_finish = true;
5148 board_info->btdm_ant_num_by_ant_det = 2;
5149 coex_sta->isolation_btween_wb = (u8)(85 -
5150 psd_scan->ant_det_psd_scan_peak_val /
5152 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5153 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Good-Isolation!!\n");
5154 BTC_TRACE(trace_buf);
5155 } else if (psd_scan->ant_det_psd_scan_peak_val >
5156 (BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT) *
5158 psd_scan->ant_det_result = 3;
5159 ant_det_finish = true;
5160 board_info->btdm_ant_num_by_ant_det = 1;
5161 coex_sta->isolation_btween_wb = (u8)(85 -
5162 psd_scan->ant_det_psd_scan_peak_val /
5164 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5165 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant!!\n");
5166 BTC_TRACE(trace_buf);
5168 psd_scan->ant_det_result = 4;
5169 ant_det_finish = false;
5170 board_info->btdm_ant_num_by_ant_det = 1;
5171 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5172 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant, un-certainity!!\n");
5173 BTC_TRACE(trace_buf);
5178 case 99: /* restore setup */
5180 /* Set AFH mask off at WiFi channel 2472MHz +/- 10MHz */
5181 h2c_parameter[0] = 0x0;
5182 h2c_parameter[1] = 0x0;
5183 h2c_parameter[2] = 0x0;
5185 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5186 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
5187 h2c_parameter[1], h2c_parameter[2]);
5188 BTC_TRACE(trace_buf);
5190 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
5193 /* Set Antenna Path, GNT_WL/GNT_BT control by PTA */
5194 /* Set Antenna path, switch WiFi to certain antenna port */
5195 halbtc8723d2ant_set_ant_path(btcoexist,
5196 BTC_ANT_PATH_AUTO, FORCE_EXEC,
5197 BT_8723D_2ANT_PHASE_2G_RUNTIME);
5199 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5200 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to PTA\n!!");
5201 BTC_TRACE(trace_buf);
5203 btcoexist->stop_coex_dm = false;
5205 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5206 "xxxxxxxxxxxxxxxx AntennaDetect(), Resume Coex DM\n!!");
5207 BTC_TRACE(trace_buf);
5215 return ant_det_finish;
5219 #ifdef PLATFORM_WINDOWS
5220 #pragma optimize("", off)
5222 boolean halbtc8723d2ant_psd_antenna_detection_check(IN struct btc_coexist
5225 static u32 ant_det_count = 0, ant_det_fail_count = 0;
5226 struct btc_board_info *board_info = &btcoexist->board_info;
5228 boolean scan, roam, ant_det_finish = false;
5230 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
5231 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
5235 psd_scan->ant_det_try_count = ant_det_count;
5238 ant_det_finish = false;
5239 psd_scan->ant_det_result = 6;
5240 } else if (coex_sta->bt_disabled) {
5241 ant_det_finish = false;
5242 psd_scan->ant_det_result = 11;
5243 } else if (coex_sta->num_of_profile >= 1) {
5244 ant_det_finish = false;
5245 psd_scan->ant_det_result = 7;
5247 !psd_scan->ant_det_is_ant_det_available) { /* Antenna initial setup is not ready */
5248 ant_det_finish = false;
5249 psd_scan->ant_det_result = 9;
5250 } else if (coex_sta->c2h_bt_inquiry_page) {
5251 ant_det_finish = false;
5252 psd_scan->ant_det_result = 10;
5255 ant_det_finish = halbtc8723d2ant_psd_antenna_detection(
5258 delay_ms(psd_scan->ant_det_bt_tx_time);
5262 if (!ant_det_finish)
5263 ant_det_fail_count++;
5265 psd_scan->ant_det_fail_count = ant_det_fail_count;
5267 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5268 "xxxxxxxxxxxxxxxx AntennaDetect(), result = %d, fail_count = %d, finish = %s\n",
5269 psd_scan->ant_det_result,
5270 psd_scan->ant_det_fail_count,
5271 ant_det_finish == true ? "Yes" : "No");
5272 BTC_TRACE(trace_buf);
5274 return ant_det_finish;
5279 /* ************************************************************
5280 * work around function start with wa_halbtc8723d2ant_
5281 * ************************************************************
5282 * ************************************************************
5283 * extern function start with ex_halbtc8723d2ant_
5284 * ************************************************************ */
5285 void ex_halbtc8723d2ant_power_on_setting(IN struct btc_coexist *btcoexist)
5287 struct btc_board_info *board_info = &btcoexist->board_info;
5292 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5293 "xxxxxxxxxxxxxxxx Execute 8723d 2-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
5294 BTC_TRACE(trace_buf);
5296 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5297 "Ant Det Finish = %s, Ant Det Number = %d\n",
5298 (board_info->btdm_ant_det_finish ? "Yes" : "No"),
5299 board_info->btdm_ant_num_by_ant_det);
5300 BTC_TRACE(trace_buf);
5303 btcoexist->stop_coex_dm = true;
5304 psd_scan->ant_det_is_ant_det_available = false;
5306 /* enable BB, REG_SYS_FUNC_EN such that we can write BB Register correctly. */
5307 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
5308 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
5311 /* Local setting bit define */
5312 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
5313 /* BIT1: "0" for internal switch; "1" for external switch */
5314 /* BIT2: "0" for one antenna; "1" for two antenna */
5315 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
5317 /* Set path control to WL */
5318 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x80, 0x1);
5319 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
5321 /* Check efuse 0xc3[6] for Single Antenna Path */
5322 if (board_info->single_ant_path == 0) {
5324 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
5327 } else if (board_info->single_ant_path == 1) {
5329 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
5334 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5335 "[BTCoex], ********** (Power On) single_ant_path = %d, btdm_ant_pos = %d **********\n",
5336 board_info->single_ant_path , board_info->btdm_ant_pos);
5337 BTC_TRACE(trace_buf);
5339 /* Set Antenna Path to BT side */
5340 halbtc8723d2ant_set_ant_path(btcoexist,
5343 BT_8723D_1ANT_PHASE_COEX_POWERON);
5345 /* Write Single Antenna Position to Registry to tell BT for 872db. This line can be removed
5346 since BT EFuse also add "single antenna position" in EFuse for 8723d*/
5347 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
5350 /* Save"single antenna position" info in Local register setting for FW reading, because FW may not ready at power on */
5351 if (btcoexist->chip_interface == BTC_INTF_PCI)
5352 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x3e0, u8tmp);
5353 else if (btcoexist->chip_interface == BTC_INTF_USB)
5354 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
5355 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
5356 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60, u8tmp);
5358 /* enable GNT_WL/GNT_BT debug signal to GPIO14/15 */
5359 halbtc8723d2ant_enable_gnt_to_gpio(btcoexist, true);
5361 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5362 "[BTCoex], ********** LTE coex Reg 0x38 (Power-On) = 0x%x**********\n",
5363 halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38));
5364 BTC_TRACE(trace_buf);
5366 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5367 "[BTCoex], ********** MAC Reg 0x70/ BB Reg 0x948 (Power-On) = 0x%x / 0x%x**********\n",
5368 btcoexist->btc_read_4byte(btcoexist, 0x70),
5369 btcoexist->btc_read_2byte(btcoexist, 0x948));
5370 BTC_TRACE(trace_buf);
5373 void ex_halbtc8723d2ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
5375 struct btc_board_info *board_info = &btcoexist->board_info;
5376 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
5379 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
5380 /* Local setting bit define */
5381 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
5382 /* BIT1: "0" for internal switch; "1" for external switch */
5383 /* BIT2: "0" for one antenna; "1" for two antenna */
5384 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
5385 if (btcoexist->chip_interface == BTC_INTF_USB) {
5386 /* fixed at S0 for USB interface */
5387 u8tmp |= 0x1; /* antenna inverse */
5388 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
5390 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
5391 if (board_info->single_ant_path == 0) {
5392 } else if (board_info->single_ant_path == 1) {
5394 u8tmp |= 0x1; /* antenna inverse */
5397 if (btcoexist->chip_interface == BTC_INTF_PCI)
5398 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x3e0,
5400 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
5401 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
5407 void ex_halbtc8723d2ant_init_hw_config(IN struct btc_coexist *btcoexist,
5408 IN boolean wifi_only)
5410 halbtc8723d2ant_init_hw_config(btcoexist, wifi_only);
5413 void ex_halbtc8723d2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
5416 halbtc8723d2ant_init_coex_dm(btcoexist);
5419 void ex_halbtc8723d2ant_display_coex_info(IN struct btc_coexist *btcoexist)
5421 struct btc_board_info *board_info = &btcoexist->board_info;
5422 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
5423 u8 *cli_buf = btcoexist->cli_buf;
5424 u8 u8tmp[4], i, ps_tdma_case = 0;
5427 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck, bt_coex_ver = 0;
5428 u32 fw_ver = 0, bt_patch_ver = 0;
5429 static u8 pop_report_in_10s = 0;
5431 boolean lte_coex_on = false;
5433 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5434 "\r\n ============[BT Coexist info]============");
5437 if (btcoexist->manual_control) {
5438 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5439 "\r\n ============[Under Manual Control]============");
5441 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5442 "\r\n ==========================================");
5446 if (psd_scan->ant_det_try_count == 0) {
5447 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s",
5448 "Ant PG Num/ Mech/ Pos",
5449 board_info->pg_ant_num, board_info->btdm_ant_num,
5450 (board_info->btdm_ant_pos == 1 ? "S1" : "S0"));
5453 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5454 "\r\n %-35s = %d/ %d/ %s (retry=%d/fail=%d/result=%d)",
5455 "Ant PG Num/ Mech(Ant_Det)/ Pos",
5456 board_info->pg_ant_num,
5457 board_info->btdm_ant_num_by_ant_det,
5458 (board_info->btdm_ant_pos == 1 ? "S1" : "S0"),
5459 psd_scan->ant_det_try_count,
5460 psd_scan->ant_det_fail_count,
5461 psd_scan->ant_det_result);
5464 if (board_info->btdm_ant_det_finish) {
5466 if (psd_scan->ant_det_result != 12)
5467 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5469 "Ant Det PSD Value",
5470 psd_scan->ant_det_peak_val);
5472 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5474 "Ant Det PSD Value",
5475 psd_scan->ant_det_psd_scan_peak_val
5481 if (board_info->ant_det_result_five_complete) {
5482 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5483 "\r\n %-35s = %d/ %d",
5484 "AntDet(Registry) Num/PSD Value",
5485 board_info->btdm_ant_num_by_ant_det,
5486 (board_info->antdetval & 0x7f));
5491 bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
5492 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
5493 phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
5495 bt_coex_ver = coex_sta->bt_coex_supported_version & 0xff;
5497 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5498 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
5499 "CoexVer WL/ BT_Desired/ BT_Report",
5500 glcoex_ver_date_8723d_2ant, glcoex_ver_8723d_2ant,
5501 glcoex_ver_btdesired_8723d_2ant,
5503 (bt_coex_ver == 0xff ? "Unknown" :
5504 (coex_sta->bt_disabled ? "BT-disable" :
5505 (bt_coex_ver >= glcoex_ver_btdesired_8723d_2ant ?
5506 "Match" : "Mis-Match"))));
5509 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5510 "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
5511 "W_FW/ B_FW/ Phy/ Kt",
5512 fw_ver, bt_patch_ver, phyver,
5513 coex_sta->cut_version + 65);
5516 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
5517 "Wifi channel informed to BT",
5518 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
5519 coex_dm->wifi_chnl_info[2]);
5522 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d ",
5523 "Isolation/WL_Thres/BT_Thres",
5524 coex_sta->isolation_btween_wb,
5525 coex_sta->wifi_coex_thres,
5526 coex_sta->bt_coex_thres);
5530 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5531 "============[Wifi Status]============");
5533 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
5535 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5536 "============[BT Status]============");
5539 pop_report_in_10s++;
5540 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5541 "\r\n %-35s = [%s/ %d dBm/ %d/ %d] ",
5542 "BT [status/ rssi/ retryCnt/ popCnt]",
5543 ((coex_sta->bt_disabled) ? ("disabled") : ((
5544 coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page")
5545 : ((BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
5546 coex_dm->bt_status) ? "non-connected idle" :
5547 ((BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
5548 ? "connected-idle" : "busy")))),
5549 coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
5550 coex_sta->pop_event_cnt);
5553 if (pop_report_in_10s >= 5) {
5554 coex_sta->pop_event_cnt = 0;
5555 pop_report_in_10s = 0;
5559 if (coex_sta->num_of_profile != 0)
5560 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5561 "\r\n %-35s = %s%s%s%s%s",
5563 ((bt_link_info->a2dp_exist) ? "A2DP," : ""),
5564 ((bt_link_info->sco_exist) ? "SCO," : ""),
5565 ((bt_link_info->hid_exist) ?
5566 ((coex_sta->hid_busy_num >= 2) ? "HID(4/18)," :
5567 "HID(2/18),") : ""),
5568 ((bt_link_info->pan_exist) ? "PAN," : ""),
5569 ((coex_sta->voice_over_HOGP) ? "Voice" : ""));
5571 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5572 "\r\n %-35s = None",
5578 if (bt_link_info->a2dp_exist) {
5579 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s",
5580 "A2DP Rate/Bitpool/Auto_Slot",
5581 ((coex_sta->is_A2DP_3M) ? "3M" : "No_3M"),
5582 coex_sta->a2dp_bit_pool,
5583 ((coex_sta->is_autoslot) ? "On" : "Off")
5588 if (bt_link_info->hid_exist) {
5589 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5590 "HID PairNum/Forbid_Slot",
5591 coex_sta->hid_pair_cnt,
5592 coex_sta->forbidden_slot
5597 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %s/ 0x%x/ 0x%x",
5598 "Role/IgnWlanAct/Feature/BLEScan",
5599 ((bt_link_info->slave_role) ? "Slave" : "Master"),
5600 ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
5601 coex_sta->bt_coex_supported_feature,
5602 coex_sta->bt_ble_scan_type);
5605 if ((coex_sta->bt_ble_scan_type & 0x7) != 0x0) {
5606 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5607 "\r\n %-35s = 0x%08x/ 0x%08x/ 0x%08x",
5608 "BLEScan Intv-Win TV/Init/Ble",
5609 (coex_sta->bt_ble_scan_type & 0x1 ?
5610 coex_sta->bt_ble_scan_para[0] : 0x0),
5611 (coex_sta->bt_ble_scan_type & 0x2 ?
5612 coex_sta->bt_ble_scan_para[1] : 0x0),
5613 (coex_sta->bt_ble_scan_type & 0x4 ?
5614 coex_sta->bt_ble_scan_para[2] : 0x0));
5619 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
5620 "ReInit/ReLink/IgnWlact/Page/NameReq",
5621 coex_sta->cnt_ReInit,
5622 coex_sta->cnt_setupLink,
5623 coex_sta->cnt_IgnWlanAct,
5625 coex_sta->cnt_RemoteNameReq
5629 halbtc8723d2ant_read_score_board(btcoexist, &u16tmp[0]);
5631 if ((coex_sta->bt_reg_vendor_ae == 0xffff) ||
5632 (coex_sta->bt_reg_vendor_ac == 0xffff))
5633 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = x/ x/ %04x",
5634 "0xae[4]/0xac[1:0]/Scoreboard", u16tmp[0]);
5636 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5637 "\r\n %-35s = 0x%x/ 0x%x/ %04x",
5638 "0xae[4]/0xac[1:0]/Scoreboard",
5639 (unsigned int)((coex_sta->bt_reg_vendor_ae & BIT(4)) >> 4),
5640 coex_sta->bt_reg_vendor_ac & 0x3, u16tmp[0]);
5643 if (coex_sta->num_of_profile > 0) {
5645 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5646 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
5648 coex_sta->bt_afh_map[0],
5649 coex_sta->bt_afh_map[1],
5650 coex_sta->bt_afh_map[2],
5651 coex_sta->bt_afh_map[3],
5652 coex_sta->bt_afh_map[4],
5653 coex_sta->bt_afh_map[5],
5654 coex_sta->bt_afh_map[6],
5655 coex_sta->bt_afh_map[7],
5656 coex_sta->bt_afh_map[8],
5657 coex_sta->bt_afh_map[9]
5662 for (i = 0; i < BT_INFO_SRC_8723D_2ANT_MAX; i++) {
5663 if (coex_sta->bt_info_c2h_cnt[i]) {
5664 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5665 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x (%d)",
5666 glbt_info_src_8723d_2ant[i],
5667 coex_sta->bt_info_c2h[i][0],
5668 coex_sta->bt_info_c2h[i][1],
5669 coex_sta->bt_info_c2h[i][2],
5670 coex_sta->bt_info_c2h[i][3],
5671 coex_sta->bt_info_c2h[i][4],
5672 coex_sta->bt_info_c2h[i][5],
5673 coex_sta->bt_info_c2h[i][6],
5674 coex_sta->bt_info_c2h_cnt[i]);
5680 if (btcoexist->manual_control)
5681 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5682 "============[mechanism] (before Manual)============");
5684 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5685 "============[Mechanism]============");
5690 ps_tdma_case = coex_dm->cur_ps_tdma;
5692 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5693 "\r\n %-35s = %02x %02x %02x %02x %02x (case-%d, %s, %s)",
5695 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
5696 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
5697 coex_dm->ps_tdma_para[4], ps_tdma_case,
5698 (coex_dm->cur_ps_tdma_on ? "TDMA On" : "TDMA Off"),
5699 (coex_dm->is_switch_to_1dot5_ant ? "1.5Ant" : "2Ant"));
5702 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
5703 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
5704 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
5705 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5706 "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
5707 "Table/0x6c0/0x6c4/0x6c8",
5708 coex_sta->coex_table_type, u32tmp[0], u32tmp[1], u32tmp[2]);
5711 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
5712 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
5713 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5714 "\r\n %-35s = 0x%x/ 0x%x",
5716 u8tmp[0], u32tmp[0]);
5719 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
5721 ((board_info->ant_div_cfg) ? "On" : "Off"),
5722 ((coex_sta->force_lps_on) ? "On" : "Off"));
5725 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5726 "WL_DACSwing/ BT_Dec_Pwr", coex_dm->cur_fw_dac_swing_lvl,
5727 coex_dm->cur_bt_dec_pwr_lvl);
5730 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
5731 lte_coex_on = ((u32tmp[0] & BIT(7)) >> 7) ? true : false;
5735 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5737 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5740 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5741 "LTE Coex Table W_L/B_L",
5742 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff);
5745 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5747 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5749 u32tmp[2] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5751 u32tmp[3] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5754 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5755 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5756 "LTE Break Table W_L/B_L/L_W/L_B",
5757 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff,
5758 u32tmp[2] & 0xffff, u32tmp[3] & 0xffff);
5764 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5765 "============[Hw setting]============");
5768 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
5769 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
5770 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
5771 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
5772 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
5773 "0x430/0x434/0x42a/0x456",
5774 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
5777 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
5778 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
5779 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x73);
5781 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
5782 "LTE Coex/Path Owner",
5783 ((lte_coex_on) ? "On" : "Off") ,
5784 ((u8tmp[0] & BIT(2)) ? "WL" : "BT"));
5788 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5789 "\r\n %-35s = %d/ %d/ %d/ %d",
5790 "LTE 3Wire/OPMode/UART/UARTMode",
5791 (int)((u32tmp[0] & BIT(6)) >> 6),
5792 (int)((u32tmp[0] & (BIT(5) | BIT(4))) >> 4),
5793 (int)((u32tmp[0] & BIT(3)) >> 3),
5794 (int)(u32tmp[0] & (BIT(2) | BIT(1) | BIT(0))));
5797 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5798 "LTE_Busy/UART_Busy",
5799 (int)((u32tmp[1] & BIT(1)) >> 1), (int)(u32tmp[1] & BIT(0)));
5803 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5804 "\r\n %-35s = %s (BB:%s)/ %s (BB:%s)/ %s %d",
5805 "GNT_WL_Ctrl/GNT_BT_Ctrl/Dbg",
5806 ((u32tmp[0] & BIT(12)) ? "SW" : "HW"),
5807 ((u32tmp[0] & BIT(8)) ? "SW" : "HW"),
5808 ((u32tmp[0] & BIT(14)) ? "SW" : "HW"),
5809 ((u32tmp[0] & BIT(10)) ? "SW" : "HW"),
5810 ((u8tmp[0] & BIT(3)) ? "On" : "Off"),
5811 coex_sta->gnt_error_cnt);
5814 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5816 (int)((u32tmp[1] & BIT(2)) >> 2),
5817 (int)((u32tmp[1] & BIT(3)) >> 3));
5820 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x948);
5821 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
5823 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5825 u16tmp[0], (int)((u8tmp[0] & BIT(7)) >> 7));
5828 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x964);
5829 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x864);
5830 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0xab7);
5831 u8tmp[3] = btcoexist->btc_read_1byte(btcoexist, 0xa01);
5833 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5834 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5835 "0x964[1]/0x864[0]/0xab7[5]/0xa01[7]",
5836 (int)((u8tmp[0] & BIT(1)) >> 1), (int)((u8tmp[1] & BIT(0))),
5837 (int)((u8tmp[2] & BIT(3)) >> 3),
5838 (int)((u8tmp[3] & BIT(7)) >> 7));
5842 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x4c6);
5843 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
5844 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x45e);
5846 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
5847 "0x4c6[4]/0x40[5]/0x45e[3](TxRetry)",
5848 (int)((u8tmp[0] & BIT(4)) >> 4),
5849 (int)((u8tmp[1] & BIT(5)) >> 5),
5850 (int)((u8tmp[2] & BIT(3)) >> 3));
5853 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
5854 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
5855 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x953);
5856 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ %s",
5857 "0x550/0x522/4-RxAGC",
5858 u32tmp[0], u8tmp[0], (u8tmp[1] & 0x2) ? "On" : "Off");
5861 fa_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_OFDM);
5862 fa_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_CCK);
5863 cca_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_OFDM);
5864 cca_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_CCK);
5866 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5867 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5868 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA",
5869 cca_cck, fa_cck, cca_ofdm, fa_ofdm);
5873 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
5874 "CRC_OK CCK/11g/11n/11n-agg",
5875 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
5876 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht);
5879 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
5880 "CRC_Err CCK/11g/11n/11n-agg",
5881 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
5882 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
5886 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d",
5887 "WlHiPri/ Locking/ Locked/ Noisy",
5888 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
5889 (coex_sta->cck_lock ? "Yes" : "No"),
5890 (coex_sta->cck_ever_lock ? "Yes" : "No"),
5891 coex_sta->wl_noisy_level);
5894 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
5895 "0x770(Hi-pri rx/tx)",
5896 coex_sta->high_priority_rx, coex_sta->high_priority_tx,
5897 (coex_sta->is_hiPri_rx_overhead ? "(scan overhead!!)" : ""));
5900 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
5901 "0x774(Lo-pri rx/tx)",
5902 coex_sta->low_priority_rx, coex_sta->low_priority_tx,
5903 (bt_link_info->slave_role ? "(Slave!!)" : (
5904 coex_sta->is_tdma_btautoslot_hang ? "(auto-slot hang!!)" : "")));
5907 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
5911 void ex_halbtc8723d2ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
5913 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
5916 if (BTC_IPS_ENTER == type) {
5917 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5918 "[BTCoex], IPS ENTER notify\n");
5919 BTC_TRACE(trace_buf);
5920 coex_sta->under_ips = true;
5921 coex_sta->under_lps = false;
5923 halbtc8723d2ant_post_state_to_bt(btcoexist,
5924 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
5925 BT_8723D_2ANT_SCOREBOARD_ONOFF |
5926 BT_8723D_2ANT_SCOREBOARD_SCAN |
5927 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
5930 halbtc8723d2ant_set_ant_path(btcoexist,
5933 BT_8723D_2ANT_PHASE_WLAN_OFF);
5935 halbtc8723d2ant_action_coex_all_off(btcoexist);
5936 } else if (BTC_IPS_LEAVE == type) {
5937 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5938 "[BTCoex], IPS LEAVE notify\n");
5939 BTC_TRACE(trace_buf);
5940 coex_sta->under_ips = false;
5942 halbtc8723d2ant_post_state_to_bt(btcoexist,
5943 BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5945 halbtc8723d2ant_post_state_to_bt(btcoexist,
5946 BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
5948 halbtc8723d2ant_init_hw_config(btcoexist, false);
5949 halbtc8723d2ant_init_coex_dm(btcoexist);
5950 halbtc8723d2ant_query_bt_info(btcoexist);
5954 void ex_halbtc8723d2ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
5956 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
5959 if (BTC_LPS_ENABLE == type) {
5960 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5961 "[BTCoex], LPS ENABLE notify\n");
5962 BTC_TRACE(trace_buf);
5963 coex_sta->under_lps = true;
5964 coex_sta->under_ips = false;
5966 if (coex_sta->force_lps_on == true) { /* LPS No-32K */
5967 /* Write WL "Active" in Score-board for PS-TDMA */
5968 halbtc8723d2ant_post_state_to_bt(btcoexist,
5969 BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5971 } else { /* LPS-32K, need check if this h2c 0x71 can work?? (2015/08/28) */
5972 /* Write WL "Non-Active" in Score-board for Native-PS */
5973 halbtc8723d2ant_post_state_to_bt(btcoexist,
5974 BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
5978 } else if (BTC_LPS_DISABLE == type) {
5979 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5980 "[BTCoex], LPS DISABLE notify\n");
5981 BTC_TRACE(trace_buf);
5982 coex_sta->under_lps = false;
5984 halbtc8723d2ant_post_state_to_bt(btcoexist,
5985 BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5989 void ex_halbtc8723d2ant_scan_notify(IN struct btc_coexist *btcoexist,
5994 boolean wifi_connected = false;
5997 if (btcoexist->manual_control ||
5998 btcoexist->stop_coex_dm)
6001 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
6004 /* this can't be removed for RF off_on event, or BT would dis-connect */
6005 halbtc8723d2ant_query_bt_info(btcoexist);
6007 if (BTC_SCAN_START == type) {
6009 if (!wifi_connected)
6010 coex_sta->wifi_is_high_pri_task = true;
6012 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6013 "[BTCoex], SCAN START notify\n");
6014 BTC_TRACE(trace_buf);
6016 halbtc8723d2ant_post_state_to_bt(btcoexist,
6017 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6018 BT_8723D_2ANT_SCOREBOARD_SCAN |
6019 BT_8723D_2ANT_SCOREBOARD_ONOFF,
6022 halbtc8723d2ant_set_ant_path(btcoexist,
6025 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6027 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6029 } else if (BTC_SCAN_FINISH == type) {
6031 coex_sta->wifi_is_high_pri_task = false;
6033 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
6034 &coex_sta->scan_ap_num);
6036 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6037 "[BTCoex], SCAN FINISH notify (Scan-AP = %d)\n",
6038 coex_sta->scan_ap_num);
6039 BTC_TRACE(trace_buf);
6041 halbtc8723d2ant_post_state_to_bt(btcoexist,
6042 BT_8723D_2ANT_SCOREBOARD_SCAN, false);
6044 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6049 void ex_halbtc8723d2ant_connect_notify(IN struct btc_coexist *btcoexist,
6052 if (btcoexist->manual_control ||
6053 btcoexist->stop_coex_dm)
6056 if (BTC_ASSOCIATE_START == type) {
6058 coex_sta->wifi_is_high_pri_task = true;
6060 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6061 "[BTCoex], CONNECT START notify\n");
6062 BTC_TRACE(trace_buf);
6064 halbtc8723d2ant_post_state_to_bt(btcoexist,
6065 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6066 BT_8723D_2ANT_SCOREBOARD_SCAN |
6067 BT_8723D_2ANT_SCOREBOARD_ONOFF,
6070 halbtc8723d2ant_set_ant_path(btcoexist,
6073 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6075 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6076 /* To keep TDMA case during connect process,
6077 to avoid changed by Btinfo and runcoexmechanism */
6078 coex_sta->freeze_coexrun_by_btinfo = true;
6080 coex_dm->arp_cnt = 0;
6082 } else if (BTC_ASSOCIATE_FINISH == type) {
6084 coex_sta->wifi_is_high_pri_task = false;
6085 coex_sta->freeze_coexrun_by_btinfo = false;
6087 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6088 "[BTCoex], CONNECT FINISH notify\n");
6089 BTC_TRACE(trace_buf);
6091 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6095 void ex_halbtc8723d2ant_media_status_notify(IN struct btc_coexist *btcoexist,
6098 u8 h2c_parameter[3] = {0};
6100 u8 wifi_central_chnl;
6102 boolean wifi_under_b_mode = false;
6104 if (btcoexist->manual_control ||
6105 btcoexist->stop_coex_dm)
6108 if (BTC_MEDIA_CONNECT == type) {
6110 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6111 "[BTCoex], MEDIA connect notify\n");
6112 BTC_TRACE(trace_buf);
6114 halbtc8723d2ant_post_state_to_bt(btcoexist,
6115 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6116 BT_8723D_2ANT_SCOREBOARD_ONOFF,
6119 halbtc8723d2ant_set_ant_path(btcoexist,
6122 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6124 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
6125 &wifi_under_b_mode);
6127 /* Set CCK Tx/Rx high Pri except 11b mode */
6128 if (wifi_under_b_mode) {
6129 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
6131 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
6135 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
6137 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
6142 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6143 "[BTCoex], MEDIA disconnect notify\n");
6144 BTC_TRACE(trace_buf);
6146 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
6147 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
6149 halbtc8723d2ant_post_state_to_bt(btcoexist,
6150 BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
6154 halbtc8723d2ant_update_wifi_channel_info(btcoexist, type);
6157 void ex_halbtc8723d2ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
6160 boolean under_4way = false;
6162 if (btcoexist->manual_control ||
6163 btcoexist->stop_coex_dm)
6166 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
6171 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6172 "[BTCoex], specific Packet ---- under_4way!!\n");
6173 BTC_TRACE(trace_buf);
6175 coex_sta->wifi_is_high_pri_task = true;
6176 coex_sta->specific_pkt_period_cnt = 2;
6178 } else if (BTC_PACKET_ARP == type) {
6181 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6182 "[BTCoex], specific Packet ARP notify -cnt = %d\n",
6184 BTC_TRACE(trace_buf);
6188 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6189 "[BTCoex], specific Packet DHCP or EAPOL notify [Type = %d]\n",
6191 BTC_TRACE(trace_buf);
6193 coex_sta->wifi_is_high_pri_task = true;
6194 coex_sta->specific_pkt_period_cnt = 2;
6197 if (coex_sta->wifi_is_high_pri_task) {
6198 halbtc8723d2ant_post_state_to_bt(btcoexist,
6199 BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6200 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6205 void ex_halbtc8723d2ant_bt_info_notify(IN struct btc_coexist *btcoexist,
6206 IN u8 *tmp_buf, IN u8 length)
6208 u8 i, rsp_source = 0;
6209 boolean wifi_connected = false;
6210 boolean wifi_scan = false, wifi_link = false, wifi_roam = false,
6212 static boolean is_scoreboard_scan = false;
6214 if (psd_scan->is_AntDet_running == true) {
6215 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6216 "[BTCoex], bt_info_notify return for AntDet is running\n");
6217 BTC_TRACE(trace_buf);
6221 rsp_source = tmp_buf[0] & 0xf;
6222 if (rsp_source >= BT_INFO_SRC_8723D_2ANT_MAX)
6223 rsp_source = BT_INFO_SRC_8723D_2ANT_WIFI_FW;
6224 coex_sta->bt_info_c2h_cnt[rsp_source]++;
6226 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6227 "[BTCoex], Bt_info[%d], len=%d, data=[", rsp_source,
6229 BTC_TRACE(trace_buf);
6231 for (i = 0; i < length; i++) {
6232 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
6234 if (i == length - 1) {
6235 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
6237 BTC_TRACE(trace_buf);
6239 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
6241 BTC_TRACE(trace_buf);
6245 coex_sta->bt_info = coex_sta->bt_info_c2h[rsp_source][1];
6246 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
6247 coex_sta->bt_info_ext2 = coex_sta->bt_info_c2h[rsp_source][5];
6249 if (BT_INFO_SRC_8723D_2ANT_WIFI_FW != rsp_source) {
6251 /* if 0xff, it means BT is under WHCK test */
6252 coex_sta->bt_whck_test = ((coex_sta->bt_info == 0xff) ? true :
6255 coex_sta->bt_create_connection = ((
6256 coex_sta->bt_info_c2h[rsp_source][2] & 0x80) ? true :
6259 /* unit: %, value-100 to translate to unit: dBm */
6260 coex_sta->bt_rssi = coex_sta->bt_info_c2h[rsp_source][3] * 2 +
6263 coex_sta->c2h_bt_remote_name_req = ((
6264 coex_sta->bt_info_c2h[rsp_source][2] & 0x20) ? true :
6267 coex_sta->is_A2DP_3M = ((coex_sta->bt_info_c2h[rsp_source][2] &
6268 0x10) ? true : false);
6270 coex_sta->acl_busy = ((coex_sta->bt_info_c2h[rsp_source][1] &
6271 0x9) ? true : false);
6273 coex_sta->voice_over_HOGP = ((coex_sta->bt_info_ext & 0x10) ?
6276 coex_sta->c2h_bt_inquiry_page = ((coex_sta->bt_info &
6277 BT_INFO_8723D_2ANT_B_INQ_PAGE) ? true : false);
6279 coex_sta->a2dp_bit_pool = (((
6280 coex_sta->bt_info_c2h[rsp_source][1] & 0x49) == 0x49) ?
6281 coex_sta->bt_info_c2h[rsp_source][6] : 0);
6283 coex_sta->bt_retry_cnt = coex_sta->bt_info_c2h[rsp_source][2] &
6286 coex_sta->is_autoslot = coex_sta->bt_info_ext2 & 0x8;
6288 coex_sta->forbidden_slot = coex_sta->bt_info_ext2 & 0x7;
6290 coex_sta->hid_busy_num = (coex_sta->bt_info_ext2 & 0x30) >> 4;
6292 coex_sta->hid_pair_cnt = (coex_sta->bt_info_ext2 & 0xc0) >> 6;
6294 if (coex_sta->bt_retry_cnt >= 1)
6295 coex_sta->pop_event_cnt++;
6297 if (coex_sta->c2h_bt_remote_name_req)
6298 coex_sta->cnt_RemoteNameReq++;
6300 if (coex_sta->bt_info_ext & BIT(1))
6301 coex_sta->cnt_ReInit++;
6303 if (coex_sta->bt_info_ext & BIT(2)) {
6304 coex_sta->cnt_setupLink++;
6305 coex_sta->is_setupLink = true;
6307 coex_sta->is_setupLink = false;
6309 if (coex_sta->bt_info_ext & BIT(3))
6310 coex_sta->cnt_IgnWlanAct++;
6312 if (coex_sta->bt_create_connection) {
6313 coex_sta->cnt_Page++;
6315 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
6318 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
6319 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
6320 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
6322 if ((wifi_link) || (wifi_roam) || (wifi_scan) ||
6323 (coex_sta->wifi_is_high_pri_task) || (wifi_busy)) {
6325 is_scoreboard_scan = true;
6326 halbtc8723d2ant_post_state_to_bt(btcoexist,
6327 BT_8723D_2ANT_SCOREBOARD_SCAN, true);
6330 halbtc8723d2ant_post_state_to_bt(btcoexist,
6331 BT_8723D_2ANT_SCOREBOARD_SCAN, false);
6334 if (is_scoreboard_scan) {
6335 halbtc8723d2ant_post_state_to_bt(btcoexist,
6336 BT_8723D_2ANT_SCOREBOARD_SCAN, false);
6337 is_scoreboard_scan = false;
6341 /* Here we need to resend some wifi info to BT */
6342 /* because bt is reset and loss of the info. */
6344 if ((!btcoexist->manual_control) &&
6345 (!btcoexist->stop_coex_dm)) {
6347 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
6351 if ((coex_sta->bt_info_ext & BIT(1))) {
6352 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6353 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
6354 BTC_TRACE(trace_buf);
6356 halbtc8723d2ant_update_wifi_channel_info(
6357 btcoexist, BTC_MEDIA_CONNECT);
6359 halbtc8723d2ant_update_wifi_channel_info(
6361 BTC_MEDIA_DISCONNECT);
6365 /* If Ignore_WLanAct && not SetUp_Link or Role_Switch */
6366 if ((coex_sta->bt_info_ext & BIT(3)) &&
6367 (!(coex_sta->bt_info_ext & BIT(2))) &&
6368 (!(coex_sta->bt_info_ext & BIT(6)))) {
6370 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6371 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
6372 BTC_TRACE(trace_buf);
6373 halbtc8723d2ant_ignore_wlan_act(btcoexist,
6376 if (coex_sta->bt_info_ext & BIT(2)) {
6377 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6378 "[BTCoex], BT ignore Wlan active because Re-link!!\n");
6379 BTC_TRACE(trace_buf);
6380 } else if (coex_sta->bt_info_ext & BIT(6)) {
6381 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6382 "[BTCoex], BT ignore Wlan active because Role-Switch!!\n");
6383 BTC_TRACE(trace_buf);
6390 if ((coex_sta->bt_info_ext & BIT(5))) {
6391 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6392 "[BTCoex], BT ext info bit4 check, query BLE Scan type!!\n");
6393 BTC_TRACE(trace_buf);
6394 coex_sta->bt_ble_scan_type = btcoexist->btc_get_ble_scan_type_from_bt(btcoexist);
6396 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1)
6397 coex_sta->bt_ble_scan_para[0] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x1);
6398 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2)
6399 coex_sta->bt_ble_scan_para[1] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x2);
6400 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4)
6401 coex_sta->bt_ble_scan_para[2] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x4);
6404 halbtc8723d2ant_update_bt_link_info(btcoexist);
6406 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6409 void ex_halbtc8723d2ant_rf_status_notify(IN struct btc_coexist *btcoexist,
6412 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
6413 BTC_TRACE(trace_buf);
6415 if (BTC_RF_ON == type) {
6416 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6417 "[BTCoex], RF is turned ON!!\n");
6418 BTC_TRACE(trace_buf);
6420 btcoexist->stop_coex_dm = false;
6422 halbtc8723d2ant_post_state_to_bt(btcoexist,
6423 BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6424 halbtc8723d2ant_post_state_to_bt(btcoexist,
6425 BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
6427 } else if (BTC_RF_OFF == type) {
6428 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6429 "[BTCoex], RF is turned OFF!!\n");
6430 BTC_TRACE(trace_buf);
6432 halbtc8723d2ant_set_ant_path(btcoexist,
6435 BT_8723D_2ANT_PHASE_WLAN_OFF);
6437 halbtc8723d2ant_action_coex_all_off(btcoexist);
6439 halbtc8723d2ant_post_state_to_bt(btcoexist,
6440 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6441 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6442 BT_8723D_2ANT_SCOREBOARD_SCAN |
6443 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6446 btcoexist->stop_coex_dm = true;
6451 void ex_halbtc8723d2ant_halt_notify(IN struct btc_coexist *btcoexist)
6453 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
6454 BTC_TRACE(trace_buf);
6456 halbtc8723d2ant_set_ant_path(btcoexist,
6459 BT_8723D_2ANT_PHASE_WLAN_OFF);
6461 ex_halbtc8723d2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
6463 halbtc8723d2ant_post_state_to_bt(btcoexist,
6464 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6465 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6466 BT_8723D_2ANT_SCOREBOARD_SCAN |
6467 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6471 void ex_halbtc8723d2ant_pnp_notify(IN struct btc_coexist *btcoexist,
6474 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Pnp notify\n");
6475 BTC_TRACE(trace_buf);
6477 if ((BTC_WIFI_PNP_SLEEP == pnp_state) ||
6478 (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state)) {
6479 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6480 "[BTCoex], Pnp notify to SLEEP\n");
6481 BTC_TRACE(trace_buf);
6483 /* Sinda 20150819, workaround for driver skip leave IPS/LPS to speed up sleep time. */
6484 /* Driver do not leave IPS/LPS when driver is going to sleep, so BTCoexistence think wifi is still under IPS/LPS */
6485 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch state after wakeup. */
6486 coex_sta->under_ips = false;
6487 coex_sta->under_lps = false;
6489 halbtc8723d2ant_post_state_to_bt(btcoexist,
6490 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6491 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6492 BT_8723D_2ANT_SCOREBOARD_SCAN |
6493 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6496 if (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state) {
6498 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6500 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6503 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6505 BT_8723D_2ANT_PHASE_WLAN_OFF);
6509 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
6510 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6511 "[BTCoex], Pnp notify to WAKE UP\n");
6512 BTC_TRACE(trace_buf);
6514 halbtc8723d2ant_post_state_to_bt(btcoexist,
6515 BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6516 halbtc8723d2ant_post_state_to_bt(btcoexist,
6517 BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
6522 void ex_halbtc8723d2ant_periodical(IN struct btc_coexist *btcoexist)
6524 struct btc_board_info *board_info = &btcoexist->board_info;
6525 boolean wifi_busy = false;
6528 boolean bt_relink_finish = false;
6530 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6531 "[BTCoex], ************* Periodical *************\n");
6532 BTC_TRACE(trace_buf);
6534 #if (BT_AUTO_REPORT_ONLY_8723D_2ANT == 0)
6535 halbtc8723d2ant_query_bt_info(btcoexist);
6538 halbtc8723d2ant_monitor_bt_ctr(btcoexist);
6539 halbtc8723d2ant_monitor_wifi_ctr(btcoexist);
6540 halbtc8723d2ant_monitor_bt_enable_disable(btcoexist);
6543 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
6545 /* halbtc8723d2ant_read_score_board(btcoexist, &bt_scoreboard_val); */
6548 halbtc8723d2ant_post_state_to_bt(btcoexist,
6549 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, true);
6551 halbtc8723d2ant_post_state_to_bt(btcoexist,
6552 BT_8723D_2ANT_SCOREBOARD_WLBUSY, true);
6554 if (bt_scoreboard_val & BIT(6))
6555 halbtc8723d2ant_query_bt_info(btcoexist); */
6557 halbtc8723d2ant_post_state_to_bt(btcoexist,
6558 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, false);
6560 halbtc8723d2ant_post_state_to_bt(btcoexist,
6561 BT_8723D_2ANT_SCOREBOARD_WLBUSY,
6566 if (coex_sta->bt_relink_downcount != 0) {
6567 coex_sta->bt_relink_downcount--;
6569 if (coex_sta->bt_relink_downcount == 0)
6570 bt_relink_finish = true;
6573 /* for 4-way, DHCP, EAPOL packet */
6574 if (coex_sta->specific_pkt_period_cnt > 0) {
6576 coex_sta->specific_pkt_period_cnt--;
6578 if ((coex_sta->specific_pkt_period_cnt == 0) &&
6579 (coex_sta->wifi_is_high_pri_task))
6580 coex_sta->wifi_is_high_pri_task = false;
6582 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6583 "[BTCoex], ***************** Hi-Pri Task = %s*****************\n",
6584 (coex_sta->wifi_is_high_pri_task ? "Yes" :
6586 BTC_TRACE(trace_buf);
6590 if (!coex_sta->bt_disabled) {
6591 if (coex_sta->bt_coex_supported_feature == 0)
6592 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_FEATURE,
6593 &coex_sta->bt_coex_supported_feature);
6595 if ((coex_sta->bt_coex_supported_version == 0) ||
6596 (coex_sta->bt_coex_supported_version == 0xffff))
6597 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_VERSION,
6598 &coex_sta->bt_coex_supported_version);
6600 if (coex_sta->bt_reg_vendor_ac == 0xffff)
6601 coex_sta->bt_reg_vendor_ac = (u16)(
6602 btcoexist->btc_get_bt_reg(btcoexist, 3,
6605 if (coex_sta->bt_reg_vendor_ae == 0xffff)
6606 coex_sta->bt_reg_vendor_ae = (u16)(
6607 btcoexist->btc_get_bt_reg(btcoexist, 3,
6610 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
6612 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
6614 if (coex_sta->num_of_profile > 0) {
6618 btcoexist->btc_get_bt_afh_map_from_bt(btcoexist, 0,
6619 &coex_sta->bt_afh_map[0]);
6624 #if BT_8723D_2ANT_ANTDET_ENABLE
6626 if (board_info->btdm_ant_det_finish) {
6627 if ((psd_scan->ant_det_result == 12) &&
6628 (psd_scan->ant_det_psd_scan_peak_val == 0)
6629 && (!psd_scan->is_AntDet_running))
6630 psd_scan->ant_det_psd_scan_peak_val =
6631 btcoexist->btc_get_ant_det_val_from_bt(
6639 if (halbtc8723d2ant_is_wifibt_status_changed(btcoexist))
6640 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6643 void ex_halbtc8723d2ant_set_antenna_notify(IN struct btc_coexist *btcoexist,
6646 struct btc_board_info *board_info = &btcoexist->board_info;
6648 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
6651 if (type == 2) { /* two antenna */
6652 board_info->ant_div_cfg = true;
6654 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
6656 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6658 } else { /* one antenna */
6660 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6662 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6667 #ifdef PLATFORM_WINDOWS
6668 #pragma optimize("", off)
6670 void ex_halbtc8723d2ant_antenna_detection(IN struct btc_coexist *btcoexist,
6671 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
6674 static u32 ant_det_count = 0, ant_det_fail_count = 0;
6675 struct btc_board_info *board_info = &btcoexist->board_info;
6679 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6680 "xxxxxxxxxxxxxxxx Ext Call AntennaDetect()!!\n");
6681 BTC_TRACE(trace_buf);
6683 #if BT_8723D_2ANT_ANTDET_ENABLE
6685 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6686 "xxxxxxxxxxxxxxxx Call AntennaDetect()!!\n");
6687 BTC_TRACE(trace_buf);
6690 psd_scan->ant_det_try_count = 0;
6691 psd_scan->ant_det_fail_count = 0;
6693 ant_det_fail_count = 0;
6694 board_info->btdm_ant_det_finish = false;
6695 board_info->btdm_ant_num_by_ant_det = 1;
6699 if (!board_info->btdm_ant_det_finish) {
6700 psd_scan->ant_det_inteval_count =
6701 psd_scan->ant_det_inteval_count + 2;
6703 if (psd_scan->ant_det_inteval_count >=
6704 BT_8723D_2ANT_ANTDET_RETRY_INTERVAL) {
6705 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6706 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is up, Try Detect!!\n");
6707 BTC_TRACE(trace_buf);
6709 psd_scan->is_AntDet_running = true;
6711 halbtc8723d2ant_read_score_board(btcoexist, &u16tmp);
6714 2)) { /* Antenna detection is already done before last WL power on */
6715 board_info->btdm_ant_det_finish = true;
6716 psd_scan->ant_det_try_count = 1;
6717 psd_scan->ant_det_fail_count = 0;
6718 board_info->btdm_ant_num_by_ant_det = (u16tmp &
6720 psd_scan->ant_det_result = 12;
6722 psd_scan->ant_det_psd_scan_peak_val =
6723 btcoexist->btc_get_ant_det_val_from_bt(
6726 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6727 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Result from BT (%d-Ant)\n",
6728 board_info->btdm_ant_num_by_ant_det);
6729 BTC_TRACE(trace_buf);
6731 board_info->btdm_ant_det_finish =
6732 halbtc8723d2ant_psd_antenna_detection_check(
6735 btcoexist->bdontenterLPS = false;
6737 if (board_info->btdm_ant_det_finish) {
6738 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6739 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Success!!\n");
6740 BTC_TRACE(trace_buf);
6742 /*for 8723d, btc_set_bt_trx_mask is just used to
6743 notify BT stop le tx and Ant Det Result , not set BT RF TRx Mask */
6744 if (psd_scan->ant_det_result != 12) {
6747 psd_scan->ant_det_psd_scan_peak_val
6751 (board_info->btdm_ant_num_by_ant_det
6752 == 1) ? (AntDetval | 0x80) :
6755 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6756 "xxxxxx AntennaDetect(), Ant Count = %d, PSD Val = %d\n",
6761 BTC_TRACE(trace_buf);
6763 if (btcoexist->btc_set_bt_trx_mask(
6764 btcoexist, AntDetval))
6765 BTC_SPRINTF(trace_buf,
6767 "xxxxxx AntennaDetect(), Notify BT stop le tx by set_bt_trx_mask ok!\n");
6769 BTC_SPRINTF(trace_buf,
6771 "xxxxxx AntennaDetect(), Notify BT stop le tx by set_bt_trx_mask fail!\n");
6773 BTC_TRACE(trace_buf);
6775 board_info->antdetval =
6776 psd_scan->ant_det_psd_scan_peak_val/100;
6778 board_info->btdm_ant_det_complete_fail = false;
6781 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6782 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Fail!!\n");
6783 BTC_TRACE(trace_buf);
6786 psd_scan->ant_det_inteval_count = 0;
6787 psd_scan->is_AntDet_running = false;
6789 /* stimulate coex running */
6790 halbtc8723d2ant_run_coexist_mechanism(
6792 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6793 "xxxxxxxxxxxxxxxx AntennaDetect(), Stimulate Coex running\n!!");
6794 BTC_TRACE(trace_buf);
6796 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6797 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is not up! (%d)\n",
6798 psd_scan->ant_det_inteval_count);
6799 BTC_TRACE(trace_buf);
6801 if (psd_scan->ant_det_inteval_count == 8)
6802 btcoexist->bdontenterLPS = true;
6804 btcoexist->bdontenterLPS = false;
6814 void ex_halbtc8723d2ant_display_ant_detection(IN struct btc_coexist *btcoexist)
6817 #if BT_8723D_2ANT_ANTDET_ENABLE
6818 struct btc_board_info *board_info = &btcoexist->board_info;
6820 if (psd_scan->ant_det_try_count != 0) {
6821 halbtc8723d2ant_psd_show_antenna_detect_result(btcoexist);
6823 if (board_info->btdm_ant_det_finish)
6824 halbtc8723d2ant_psd_showdata(btcoexist);
6833 #endif /* #if (RTL8723D_SUPPORT == 1) */