1 /* ************************************************************
\r
4 * This file is for RTL8723B Co-exist mechanism
\r
7 * 2012/11/15 Cosa first check in.
\r
9 * ************************************************************ */
\r
11 /* ************************************************************
\r
13 * ************************************************************ */
\r
14 #include "Mp_Precomp.h"
\r
16 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
\r
18 #if (RTL8723B_SUPPORT == 1)
\r
19 /* ************************************************************
\r
20 * Global variables, these are static variables
\r
21 * ************************************************************ */
\r
22 static u8 *trace_buf = &gl_btc_trace_buf[0];
\r
23 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant;
\r
24 static struct coex_dm_8723b_1ant *coex_dm = &glcoex_dm_8723b_1ant;
\r
25 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant;
\r
26 static struct coex_sta_8723b_1ant *coex_sta = &glcoex_sta_8723b_1ant;
\r
27 static struct psdscan_sta_8723b_1ant gl_psd_scan_8723b_1ant;
\r
28 static struct psdscan_sta_8723b_1ant *psd_scan = &gl_psd_scan_8723b_1ant;
\r
31 const char *const glbt_info_src_8723b_1ant[]={
\r
34 "BT Info[bt auto report]",
\r
37 u32 glcoex_ver_date_8723b_1ant = 20151015;
\r
38 u32 glcoex_ver_8723b_1ant = 0x63;
\r
40 /* ************************************************************
\r
41 * local function proto type if needed
\r
42 * ************************************************************
\r
43 * ************************************************************
\r
44 * local function start with halbtc8723b1ant_
\r
45 * ************************************************************ */
\r
47 void halbtc8723b1ant_update_ra_mask(IN struct btc_coexist *btcoexist,
\r
48 IN boolean force_exec, IN u32 dis_rate_mask)
\r
50 coex_dm->cur_ra_mask = dis_rate_mask;
\r
52 if( force_exec || (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask))
\r
53 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
\r
54 &coex_dm->cur_ra_mask);
\r
55 coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
\r
58 void halbtc8723b1ant_auto_rate_fallback_retry(IN struct btc_coexist *btcoexist,
\r
59 IN boolean force_exec, IN u8 type)
\r
61 boolean wifi_under_b_mode = false;
\r
63 coex_dm->cur_arfr_type = type;
\r
65 if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
\r
66 switch (coex_dm->cur_arfr_type) {
\r
67 case 0: /* normal mode */
\r
68 btcoexist->btc_write_4byte(btcoexist, 0x430,
\r
69 coex_dm->backup_arfr_cnt1);
\r
70 btcoexist->btc_write_4byte(btcoexist, 0x434,
\r
71 coex_dm->backup_arfr_cnt2);
\r
74 btcoexist->btc_get(btcoexist,
\r
75 BTC_GET_BL_WIFI_UNDER_B_MODE,
\r
76 &wifi_under_b_mode);
\r
77 if (wifi_under_b_mode) {
\r
78 btcoexist->btc_write_4byte(btcoexist,
\r
80 btcoexist->btc_write_4byte(btcoexist,
\r
83 btcoexist->btc_write_4byte(btcoexist,
\r
85 btcoexist->btc_write_4byte(btcoexist,
\r
94 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
\r
97 void halbtc8723b1ant_retry_limit(IN struct btc_coexist *btcoexist,
\r
98 IN boolean force_exec, IN u8 type)
\r
100 coex_dm->cur_retry_limit_type = type;
\r
103 (coex_dm->pre_retry_limit_type !=
\r
104 coex_dm->cur_retry_limit_type)) {
\r
105 switch (coex_dm->cur_retry_limit_type) {
\r
106 case 0: /* normal mode */
\r
107 btcoexist->btc_write_2byte(btcoexist, 0x42a,
\r
108 coex_dm->backup_retry_limit);
\r
110 case 1: /* retry limit=8 */
\r
111 btcoexist->btc_write_2byte(btcoexist, 0x42a,
\r
119 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
\r
122 void halbtc8723b1ant_ampdu_max_time(IN struct btc_coexist *btcoexist,
\r
123 IN boolean force_exec, IN u8 type)
\r
125 coex_dm->cur_ampdu_time_type = type;
\r
128 (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
\r
129 switch (coex_dm->cur_ampdu_time_type) {
\r
130 case 0: /* normal mode */
\r
131 btcoexist->btc_write_1byte(btcoexist, 0x456,
\r
132 coex_dm->backup_ampdu_max_time);
\r
134 case 1: /* AMPDU timw = 0x38 * 32us */
\r
135 btcoexist->btc_write_1byte(btcoexist, 0x456,
\r
143 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
\r
146 void halbtc8723b1ant_limited_tx(IN struct btc_coexist *btcoexist,
\r
147 IN boolean force_exec, IN u8 ra_mask_type, IN u8 arfr_type,
\r
148 IN u8 retry_limit_type, IN u8 ampdu_time_type)
\r
150 switch (ra_mask_type) {
\r
151 case 0: /* normal mode */
\r
152 halbtc8723b1ant_update_ra_mask(btcoexist, force_exec,
\r
155 case 1: /* disable cck 1/2 */
\r
156 halbtc8723b1ant_update_ra_mask(btcoexist, force_exec,
\r
159 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
\r
160 halbtc8723b1ant_update_ra_mask(btcoexist, force_exec,
\r
167 halbtc8723b1ant_auto_rate_fallback_retry(btcoexist, force_exec,
\r
169 halbtc8723b1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
\r
170 halbtc8723b1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
\r
173 void halbtc8723b1ant_limited_rx(IN struct btc_coexist *btcoexist,
\r
174 IN boolean force_exec, IN boolean rej_ap_agg_pkt,
\r
175 IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
\r
177 boolean reject_rx_agg = rej_ap_agg_pkt;
\r
178 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
\r
179 u8 rx_agg_size = agg_buf_size;
\r
181 /* ============================================ */
\r
182 /* Rx Aggregation related setting */
\r
183 /* ============================================ */
\r
184 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
\r
186 /* decide BT control aggregation buf size or not */
\r
187 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
\r
188 &bt_ctrl_rx_agg_size);
\r
189 /* aggregation buf size, only work when BT control Rx aggregation size. */
\r
190 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
\r
191 /* real update aggregation setting */
\r
192 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
\r
197 void halbtc8723b1ant_query_bt_info(IN struct btc_coexist *btcoexist)
\r
199 u8 h2c_parameter[1] = {0};
\r
201 coex_sta->c2h_bt_info_req_sent = true;
\r
203 h2c_parameter[0] |= BIT(0); /* trigger */
\r
205 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
\r
208 void halbtc8723b1ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
\r
210 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
\r
211 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
\r
212 static u32 num_of_bt_counter_chk = 0;
\r
214 reg_hp_txrx = 0x770;
\r
215 reg_lp_txrx = 0x774;
\r
217 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
\r
218 reg_hp_tx = u32tmp & MASKLWORD;
\r
219 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
\r
221 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
\r
222 reg_lp_tx = u32tmp & MASKLWORD;
\r
223 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
\r
225 coex_sta->high_priority_tx = reg_hp_tx;
\r
226 coex_sta->high_priority_rx = reg_hp_rx;
\r
227 coex_sta->low_priority_tx = reg_lp_tx;
\r
228 coex_sta->low_priority_rx = reg_lp_rx;
\r
230 if ((coex_sta->low_priority_tx > 1050) &&
\r
231 (!coex_sta->c2h_bt_inquiry_page))
\r
232 coex_sta->pop_event_cnt++;
\r
234 /* reset counter */
\r
235 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
\r
237 /* This part is for wifi FW and driver to update BT's status as disabled. */
\r
238 /* The flow is as the following */
\r
239 /* 1. disable BT */
\r
240 /* 2. if all BT Tx/Rx counter=0, after 6 sec we query bt info */
\r
241 /* 3. Because BT will not rsp from mailbox, so wifi fw will know BT is disabled */
\r
242 /* 4. FW will rsp c2h for BT that driver will know BT is disabled. */
\r
243 if ((reg_hp_tx == 0) && (reg_hp_rx == 0) && (reg_lp_tx == 0) &&
\r
244 (reg_lp_rx == 0)) {
\r
245 num_of_bt_counter_chk++;
\r
246 if (num_of_bt_counter_chk == 3)
\r
247 halbtc8723b1ant_query_bt_info(btcoexist);
\r
249 num_of_bt_counter_chk = 0;
\r
253 void halbtc8723b1ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
\r
256 boolean wifi_busy = false, wifi_under_b_mode = false;
\r
257 static u8 cck_lock_counter = 0;
\r
260 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
261 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
\r
262 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
\r
263 &wifi_under_b_mode);
\r
265 if (coex_sta->under_ips) {
\r
266 coex_sta->crc_ok_cck = 0;
\r
267 coex_sta->crc_ok_11g = 0;
\r
268 coex_sta->crc_ok_11n = 0;
\r
269 coex_sta->crc_ok_11n_agg = 0;
\r
271 coex_sta->crc_err_cck = 0;
\r
272 coex_sta->crc_err_11g = 0;
\r
273 coex_sta->crc_err_11n = 0;
\r
274 coex_sta->crc_err_11n_agg = 0;
\r
276 coex_sta->crc_ok_cck = btcoexist->btc_read_4byte(btcoexist,
\r
278 coex_sta->crc_ok_11g = btcoexist->btc_read_2byte(btcoexist,
\r
280 coex_sta->crc_ok_11n = btcoexist->btc_read_2byte(btcoexist,
\r
282 coex_sta->crc_ok_11n_agg = btcoexist->btc_read_2byte(btcoexist,
\r
285 coex_sta->crc_err_cck = btcoexist->btc_read_4byte(btcoexist,
\r
287 coex_sta->crc_err_11g = btcoexist->btc_read_2byte(btcoexist,
\r
289 coex_sta->crc_err_11n = btcoexist->btc_read_2byte(btcoexist,
\r
291 coex_sta->crc_err_11n_agg = btcoexist->btc_read_2byte(btcoexist,
\r
296 /* reset counter */
\r
297 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
\r
298 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
\r
300 if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
\r
301 total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
\r
302 coex_sta->crc_ok_11n +
\r
303 coex_sta->crc_ok_11n_agg;
\r
305 if ( (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
\r
306 (coex_dm->bt_status ==
\r
307 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
\r
308 (coex_dm->bt_status ==
\r
309 BT_8723B_1ANT_BT_STATUS_SCO_BUSY)) {
\r
310 if (coex_sta->crc_ok_cck > (total_cnt -
\r
311 coex_sta->crc_ok_cck)) {
\r
312 if (cck_lock_counter < 3)
\r
313 cck_lock_counter++;
\r
315 if (cck_lock_counter > 0)
\r
316 cck_lock_counter--;
\r
320 if (cck_lock_counter > 0)
\r
321 cck_lock_counter--;
\r
324 if (cck_lock_counter > 0)
\r
325 cck_lock_counter--;
\r
328 if (!coex_sta->pre_ccklock) {
\r
330 if (cck_lock_counter >= 3)
\r
331 coex_sta->cck_lock = true;
\r
333 coex_sta->cck_lock = false;
\r
335 if (cck_lock_counter == 0)
\r
336 coex_sta->cck_lock = false;
\r
338 coex_sta->cck_lock = true;
\r
341 if (coex_sta->cck_lock)
\r
342 coex_sta->cck_ever_lock = true;
\r
344 coex_sta->pre_ccklock = coex_sta->cck_lock;
\r
349 boolean halbtc8723b1ant_is_wifi_status_changed(IN struct btc_coexist *btcoexist)
\r
351 static boolean pre_wifi_busy = false, pre_under_4way = false,
\r
352 pre_bt_hs_on = false;
\r
353 boolean wifi_busy = false, under_4way = false, bt_hs_on = false;
\r
354 boolean wifi_connected = false;
\r
356 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
358 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
359 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
\r
360 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
\r
363 if (wifi_connected) {
\r
364 if (wifi_busy != pre_wifi_busy) {
\r
365 pre_wifi_busy = wifi_busy;
\r
368 if (under_4way != pre_under_4way) {
\r
369 pre_under_4way = under_4way;
\r
372 if (bt_hs_on != pre_bt_hs_on) {
\r
373 pre_bt_hs_on = bt_hs_on;
\r
383 void halbtc8723b1ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
\r
385 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
386 boolean bt_hs_on = false;
\r
388 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
\r
390 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
\r
391 bt_link_info->sco_exist = coex_sta->sco_exist;
\r
392 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
\r
393 bt_link_info->pan_exist = coex_sta->pan_exist;
\r
394 bt_link_info->hid_exist = coex_sta->hid_exist;
\r
395 bt_link_info->bt_hi_pri_link_exist = coex_sta->bt_hi_pri_link_exist;
\r
397 /* work around for HS mode. */
\r
399 bt_link_info->pan_exist = true;
\r
400 bt_link_info->bt_link_exist = true;
\r
403 /* check if Sco only */
\r
404 if( bt_link_info->sco_exist &&
\r
405 !bt_link_info->a2dp_exist &&
\r
406 !bt_link_info->pan_exist &&
\r
407 !bt_link_info->hid_exist )
\r
408 bt_link_info->sco_only = true;
\r
410 bt_link_info->sco_only = false;
\r
412 /* check if A2dp only */
\r
413 if( !bt_link_info->sco_exist &&
\r
414 bt_link_info->a2dp_exist &&
\r
415 !bt_link_info->pan_exist &&
\r
416 !bt_link_info->hid_exist )
\r
417 bt_link_info->a2dp_only = true;
\r
419 bt_link_info->a2dp_only = false;
\r
421 /* check if Pan only */
\r
422 if( !bt_link_info->sco_exist &&
\r
423 !bt_link_info->a2dp_exist &&
\r
424 bt_link_info->pan_exist &&
\r
425 !bt_link_info->hid_exist )
\r
426 bt_link_info->pan_only = true;
\r
428 bt_link_info->pan_only = false;
\r
430 /* check if Hid only */
\r
431 if( !bt_link_info->sco_exist &&
\r
432 !bt_link_info->a2dp_exist &&
\r
433 !bt_link_info->pan_exist &&
\r
434 bt_link_info->hid_exist )
\r
435 bt_link_info->hid_only = true;
\r
437 bt_link_info->hid_only = false;
\r
440 void halbtc8723b1ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
\r
441 IN boolean enable_auto_report)
\r
443 u8 h2c_parameter[1] = {0};
\r
445 h2c_parameter[0] = 0;
\r
447 if (enable_auto_report)
\r
448 h2c_parameter[0] |= BIT(0);
\r
450 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
\r
453 void halbtc8723b1ant_bt_auto_report(IN struct btc_coexist *btcoexist,
\r
454 IN boolean force_exec, IN boolean enable_auto_report)
\r
456 coex_dm->cur_bt_auto_report = enable_auto_report;
\r
459 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
\r
462 halbtc8723b1ant_set_bt_auto_report(btcoexist,
\r
463 coex_dm->cur_bt_auto_report);
\r
465 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
\r
468 void halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(IN struct btc_coexist
\r
469 *btcoexist, IN boolean low_penalty_ra)
\r
471 u8 h2c_parameter[6] = {0};
\r
473 h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
\r
475 if (low_penalty_ra) {
\r
476 h2c_parameter[1] |= BIT(0);
\r
478 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
\r
479 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
\r
480 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
\r
481 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
\r
484 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
\r
487 void halbtc8723b1ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
\r
488 IN boolean force_exec, IN boolean low_penalty_ra)
\r
490 coex_dm->cur_low_penalty_ra = low_penalty_ra;
\r
493 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
\r
496 halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(btcoexist,
\r
497 coex_dm->cur_low_penalty_ra);
\r
499 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
\r
502 void halbtc8723b1ant_set_coex_table(IN struct btc_coexist *btcoexist,
\r
503 IN u32 val0x6c0, IN u32 val0x6c4, IN u32 val0x6c8, IN u8 val0x6cc)
\r
505 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
\r
507 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
\r
509 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
\r
511 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
\r
514 void halbtc8723b1ant_coex_table(IN struct btc_coexist *btcoexist,
\r
515 IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
\r
516 IN u32 val0x6c8, IN u8 val0x6cc)
\r
518 coex_dm->cur_val0x6c0 = val0x6c0;
\r
519 coex_dm->cur_val0x6c4 = val0x6c4;
\r
520 coex_dm->cur_val0x6c8 = val0x6c8;
\r
521 coex_dm->cur_val0x6cc = val0x6cc;
\r
524 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
\r
525 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
\r
526 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
\r
527 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
\r
530 halbtc8723b1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
\r
533 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
\r
534 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
\r
535 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
\r
536 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
\r
539 void halbtc8723b1ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
\r
540 IN boolean force_exec, IN u8 type)
\r
542 struct btc_board_info *board_info = &btcoexist->board_info;
\r
544 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
545 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
\r
546 if (board_info->btdm_ant_num_by_ant_det == 2) {
\r
549 else if (type == 4)
\r
551 else if (type == 5)
\r
557 coex_sta->coex_table_type = type;
\r
561 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
562 0x55555555, 0x55555555, 0xffffff, 0x3);
\r
565 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
566 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3);
\r
569 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
570 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3);
\r
573 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
574 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3);
\r
577 if ((coex_sta->cck_ever_lock) &&
\r
578 (coex_sta->scan_ap_num <= 5))
\r
579 halbtc8723b1ant_coex_table(btcoexist,
\r
580 force_exec, 0x55555555, 0xaaaa5a5a,
\r
583 halbtc8723b1ant_coex_table(btcoexist,
\r
584 force_exec, 0x55555555, 0x5a5a5a5a,
\r
588 if ((coex_sta->cck_ever_lock) &&
\r
589 (coex_sta->scan_ap_num <= 5))
\r
590 halbtc8723b1ant_coex_table(btcoexist,
\r
591 force_exec, 0x5a5a5a5a, 0x5aaa5a5a,
\r
594 halbtc8723b1ant_coex_table(btcoexist,
\r
595 force_exec, 0x5a5a5a5a, 0x5aaa5a5a,
\r
599 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
600 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3);
\r
603 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
604 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3);
\r
607 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
608 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
\r
611 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
612 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
\r
615 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
616 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
\r
619 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
620 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
\r
623 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
624 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
\r
627 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
628 0x5fff5fff, 0xaaaaaaaa, 0xffffff, 0x3);
\r
631 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
632 0x5fff5fff, 0x5ada5ada, 0xffffff, 0x3);
\r
635 halbtc8723b1ant_coex_table(btcoexist, force_exec,
\r
636 0x55dd55dd, 0xaaaaaaaa, 0xffffff, 0x3);
\r
643 void halbtc8723b1ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
\r
646 u8 h2c_parameter[1] = {0};
\r
649 h2c_parameter[0] |= BIT(0); /* function enable */
\r
652 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
\r
655 void halbtc8723b1ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
\r
656 IN boolean force_exec, IN boolean enable)
\r
658 coex_dm->cur_ignore_wlan_act = enable;
\r
661 if (coex_dm->pre_ignore_wlan_act ==
\r
662 coex_dm->cur_ignore_wlan_act)
\r
665 halbtc8723b1ant_set_fw_ignore_wlan_act(btcoexist, enable);
\r
667 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
\r
670 void halbtc8723b1ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
\r
671 IN u8 lps_val, IN u8 rpwm_val)
\r
674 u8 rpwm = rpwm_val;
\r
676 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
\r
677 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
\r
680 void halbtc8723b1ant_lps_rpwm(IN struct btc_coexist *btcoexist,
\r
681 IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
\r
683 coex_dm->cur_lps = lps_val;
\r
684 coex_dm->cur_rpwm = rpwm_val;
\r
687 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
\r
688 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
\r
691 halbtc8723b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
\r
693 coex_dm->pre_lps = coex_dm->cur_lps;
\r
694 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
\r
697 void halbtc8723b1ant_sw_mechanism(IN struct btc_coexist *btcoexist,
\r
698 IN boolean low_penalty_ra)
\r
700 halbtc8723b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
\r
703 void halbtc8723b1ant_set_ant_path(IN struct btc_coexist *btcoexist,
\r
704 IN u8 ant_pos_type, IN boolean force_exec, IN boolean init_hwcfg,
\r
705 IN boolean wifi_off)
\r
707 struct btc_board_info *board_info = &btcoexist->board_info;
\r
708 u32 fw_ver = 0, u32tmp = 0, cnt_bt_cal_chk = 0;
\r
709 boolean pg_ext_switch = false;
\r
710 boolean use_ext_switch = false;
\r
711 boolean is_in_mp_mode = false;
\r
712 u8 h2c_parameter[2] = {0}, u8tmp = 0;
\r
714 coex_dm->cur_ant_pos_type = ant_pos_type;
\r
716 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
\r
717 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER,
\r
718 &fw_ver); /* [31:16]=fw ver, [15:0]=fw sub ver */
\r
720 if ((fw_ver > 0 && fw_ver < 0xc0000) || pg_ext_switch)
\r
721 use_ext_switch = true;
\r
723 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
724 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
\r
725 if (ant_pos_type == BTC_ANT_PATH_PTA) {
\r
726 if ((board_info->btdm_ant_det_finish) &&
\r
727 (board_info->btdm_ant_num_by_ant_det == 2)) {
\r
728 if (board_info->btdm_ant_pos ==
\r
729 BTC_ANTENNA_AT_MAIN_PORT)
\r
730 ant_pos_type = BTC_ANT_PATH_WIFI;
\r
732 ant_pos_type = BTC_ANT_PATH_BT;
\r
739 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
\r
740 0x780); /* WiFi TRx Mask on */
\r
741 /* remove due to interrupt is disabled that polling c2h will fail and delay 100ms. */
\r
742 /* btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x15); //BT TRx Mask on */
\r
744 if (fw_ver >= 0x180000) {
\r
745 /* Use H2C to set GNT_BT to HIGH */
\r
746 h2c_parameter[0] = 1;
\r
747 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
\r
750 /* set grant_bt to high */
\r
751 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
\r
753 /* set wlan_act control by PTA */
\r
754 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
\r
756 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20,
\r
757 0x0); /* BT select s0/s1 is controlled by BT */
\r
759 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
\r
760 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
\r
761 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
\r
762 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
\r
763 } else if (wifi_off) {
\r
764 if (fw_ver >= 0x180000) {
\r
765 /* Use H2C to set GNT_BT to HIGH */
\r
766 h2c_parameter[0] = 1;
\r
767 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
\r
770 /* set grant_bt to high */
\r
771 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
\r
773 /* set wlan_act to always low */
\r
774 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
\r
776 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
\r
778 if (!is_in_mp_mode)
\r
779 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
\r
780 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
\r
782 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
\r
783 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
\r
785 /* 0x4c[24:23]=00, Set Antenna control by BT_RFE_CTRL BT Vendor 0xac=0xf002 */
\r
786 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
\r
787 u32tmp &= ~BIT(23);
\r
788 u32tmp &= ~BIT(24);
\r
789 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
\r
791 /* Use H2C to set GNT_BT to LOW */
\r
792 if (fw_ver >= 0x180000) {
\r
793 if (btcoexist->btc_read_1byte(btcoexist, 0x765) != 0) {
\r
794 h2c_parameter[0] = 0;
\r
795 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
\r
799 /* BT calibration check */
\r
800 while (cnt_bt_cal_chk <= 20) {
\r
801 u8tmp = btcoexist->btc_read_1byte(btcoexist,
\r
804 if (u8tmp & BIT(0)) {
\r
805 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
806 "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
\r
808 BTC_TRACE(trace_buf);
\r
811 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
812 "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
\r
814 BTC_TRACE(trace_buf);
\r
819 /* set grant_bt to PTA */
\r
820 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
\r
823 if (btcoexist->btc_read_1byte(btcoexist, 0x76e) != 0xc) {
\r
824 /* set wlan_act control by PTA */
\r
825 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
\r
828 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20,
\r
829 0x1); /* BT select s0/s1 is controlled by WiFi */
\r
832 if (use_ext_switch) {
\r
834 /* 0x4c[23]=0, 0x4c[24]=1 Antenna control by WL/BT */
\r
835 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
\r
836 u32tmp &= ~BIT(23);
\r
838 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
\r
840 btcoexist->btc_write_4byte(btcoexist, 0x948,
\r
841 0x0); /* fixed internal switch S1->WiFi, S0->BT */
\r
843 if (board_info->btdm_ant_pos ==
\r
844 BTC_ANTENNA_AT_MAIN_PORT) {
\r
845 /* tell firmware "no antenna inverse" */
\r
846 h2c_parameter[0] = 0;
\r
847 h2c_parameter[1] = 1; /* ext switch type */
\r
848 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
\r
851 /* tell firmware "antenna inverse" */
\r
852 h2c_parameter[0] = 1;
\r
853 h2c_parameter[1] = 1; /* ext switch type */
\r
854 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
\r
860 (coex_dm->cur_ant_pos_type !=
\r
861 coex_dm->pre_ant_pos_type)) {
\r
862 /* ext switch setting */
\r
863 switch (ant_pos_type) {
\r
864 case BTC_ANT_PATH_WIFI:
\r
865 if (board_info->btdm_ant_pos ==
\r
866 BTC_ANTENNA_AT_MAIN_PORT)
\r
867 btcoexist->btc_write_1byte_bitmask(
\r
868 btcoexist, 0x92c, 0x3,
\r
871 btcoexist->btc_write_1byte_bitmask(
\r
872 btcoexist, 0x92c, 0x3,
\r
875 case BTC_ANT_PATH_BT:
\r
876 if (board_info->btdm_ant_pos ==
\r
877 BTC_ANTENNA_AT_MAIN_PORT)
\r
878 btcoexist->btc_write_1byte_bitmask(
\r
879 btcoexist, 0x92c, 0x3,
\r
882 btcoexist->btc_write_1byte_bitmask(
\r
883 btcoexist, 0x92c, 0x3,
\r
887 case BTC_ANT_PATH_PTA:
\r
888 if (board_info->btdm_ant_pos ==
\r
889 BTC_ANTENNA_AT_MAIN_PORT)
\r
890 btcoexist->btc_write_1byte_bitmask(
\r
891 btcoexist, 0x92c, 0x3,
\r
894 btcoexist->btc_write_1byte_bitmask(
\r
895 btcoexist, 0x92c, 0x3,
\r
902 /* 0x4c[23]=1, 0x4c[24]=0 Antenna control by 0x64 */
\r
903 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
\r
905 u32tmp &= ~BIT(24);
\r
906 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
\r
908 /* Fix Ext switch Main->S1, Aux->S0 */
\r
909 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
\r
912 if (board_info->btdm_ant_pos ==
\r
913 BTC_ANTENNA_AT_MAIN_PORT) {
\r
915 /* tell firmware "no antenna inverse" */
\r
916 h2c_parameter[0] = 0;
\r
918 0; /* internal switch type */
\r
919 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
\r
923 /* tell firmware "antenna inverse" */
\r
924 h2c_parameter[0] = 1;
\r
926 0; /* internal switch type */
\r
927 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
\r
933 (coex_dm->cur_ant_pos_type !=
\r
934 coex_dm->pre_ant_pos_type)) {
\r
935 /* internal switch setting */
\r
936 switch (ant_pos_type) {
\r
937 case BTC_ANT_PATH_WIFI:
\r
938 if (board_info->btdm_ant_pos ==
\r
939 BTC_ANTENNA_AT_MAIN_PORT)
\r
940 btcoexist->btc_write_4byte(
\r
941 btcoexist, 0x948, 0x0);
\r
943 btcoexist->btc_write_4byte(
\r
947 case BTC_ANT_PATH_BT:
\r
948 if (board_info->btdm_ant_pos ==
\r
949 BTC_ANTENNA_AT_MAIN_PORT)
\r
950 btcoexist->btc_write_4byte(
\r
954 btcoexist->btc_write_4byte(
\r
955 btcoexist, 0x948, 0x0);
\r
958 case BTC_ANT_PATH_PTA:
\r
959 if (board_info->btdm_ant_pos ==
\r
960 BTC_ANTENNA_AT_MAIN_PORT)
\r
961 btcoexist->btc_write_4byte(
\r
965 btcoexist->btc_write_4byte(
\r
966 btcoexist, 0x948, 0x80);
\r
972 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
\r
975 void halbtc8723b1ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
\r
976 IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
\r
978 u8 h2c_parameter[5] = {0};
\r
979 u8 real_byte1 = byte1, real_byte5 = byte5;
\r
980 boolean ap_enable = false;
\r
982 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
\r
986 if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
\r
987 real_byte1 &= ~BIT(4);
\r
988 real_byte1 |= BIT(5);
\r
990 real_byte5 |= BIT(5);
\r
991 real_byte5 &= ~BIT(6);
\r
995 h2c_parameter[0] = real_byte1;
\r
996 h2c_parameter[1] = byte2;
\r
997 h2c_parameter[2] = byte3;
\r
998 h2c_parameter[3] = byte4;
\r
999 h2c_parameter[4] = real_byte5;
\r
1001 coex_dm->ps_tdma_para[0] = real_byte1;
\r
1002 coex_dm->ps_tdma_para[1] = byte2;
\r
1003 coex_dm->ps_tdma_para[2] = byte3;
\r
1004 coex_dm->ps_tdma_para[3] = byte4;
\r
1005 coex_dm->ps_tdma_para[4] = real_byte5;
\r
1007 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
\r
1011 void halbtc8723b1ant_ps_tdma(IN struct btc_coexist *btcoexist,
\r
1012 IN boolean force_exec, IN boolean turn_on, IN u8 type)
\r
1014 struct btc_board_info *board_info = &btcoexist->board_info;
\r
1015 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1016 boolean wifi_busy = false;
\r
1017 u8 rssi_adjust_val = 0;
\r
1018 u8 ps_tdma_byte4_val = 0x50, ps_tdma_byte0_val = 0x51,
\r
1019 ps_tdma_byte3_val = 0x10;
\r
1020 s8 wifi_duration_adjust = 0x0;
\r
1021 static boolean pre_wifi_busy = false;
\r
1023 coex_dm->cur_ps_tdma_on = turn_on;
\r
1024 coex_dm->cur_ps_tdma = type;
\r
1026 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
1027 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
\r
1028 if (board_info->btdm_ant_num_by_ant_det == 2) {
\r
1031 100; /* for WiFi RSSI low or BT RSSI low */
\r
1033 type = 1; /* always translate to TDMA(off,1) for TDMA-off case */
\r
1039 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
1041 if (wifi_busy != pre_wifi_busy) {
\r
1042 force_exec = true;
\r
1043 pre_wifi_busy = wifi_busy;
\r
1046 if (!force_exec) {
\r
1047 if( (coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
\r
1048 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma) )
\r
1052 if (coex_sta->scan_ap_num <= 5) {
\r
1053 wifi_duration_adjust = 5;
\r
1055 if (coex_sta->a2dp_bit_pool >= 35)
\r
1056 wifi_duration_adjust = -10;
\r
1057 else if (coex_sta->a2dp_bit_pool >= 45)
\r
1058 wifi_duration_adjust = -15;
\r
1059 } else if (coex_sta->scan_ap_num >= 40) {
\r
1060 wifi_duration_adjust = -15;
\r
1062 if (coex_sta->a2dp_bit_pool < 35)
\r
1063 wifi_duration_adjust = -5;
\r
1064 else if (coex_sta->a2dp_bit_pool < 45)
\r
1065 wifi_duration_adjust = -10;
\r
1066 } else if (coex_sta->scan_ap_num >= 20) {
\r
1067 wifi_duration_adjust = -10;
\r
1069 if (coex_sta->a2dp_bit_pool >= 45)
\r
1070 wifi_duration_adjust = -15;
\r
1072 wifi_duration_adjust = 0;
\r
1074 if (coex_sta->a2dp_bit_pool >= 35)
\r
1075 wifi_duration_adjust = -10;
\r
1076 else if (coex_sta->a2dp_bit_pool >= 45)
\r
1077 wifi_duration_adjust = -15;
\r
1080 if ((type == 1) || (type == 2) || (type == 9) || (type == 11) ||
\r
1082 || (type == 102) || (type == 109) || (type == 101)) {
\r
1083 if (!coex_sta->force_lps_on) { /* Native power save TDMA, only for A2DP-only case 1/2/9/11 while wifi noisy threshold > 30 */
\r
1084 ps_tdma_byte0_val = 0x61; /* no null-pkt */
\r
1085 ps_tdma_byte3_val = 0x11; /* no tx-pause at BT-slot */
\r
1086 ps_tdma_byte4_val =
\r
1087 0x10; /* 0x778 = d/1 toggle, no dynamic slot */
\r
1089 ps_tdma_byte0_val = 0x51; /* null-pkt */
\r
1090 ps_tdma_byte3_val = 0x10; /* tx-pause at BT-slot */
\r
1091 ps_tdma_byte4_val =
\r
1092 0x50; /* 0x778 = d/1 toggle, dynamic slot */
\r
1094 } else if ((type == 3) || (type == 13) || (type == 14) ||
\r
1095 (type == 103) || (type == 113) || (type == 114)) {
\r
1096 ps_tdma_byte0_val = 0x51; /* null-pkt */
\r
1097 ps_tdma_byte3_val = 0x10; /* tx-pause at BT-slot */
\r
1098 ps_tdma_byte4_val =
\r
1099 0x10; /* 0x778 = d/1 toggle, no dynamic slot */
\r
1102 ps_tdma_byte4_val = ps_tdma_byte4_val |
\r
1103 0x1; /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
\r
1105 } else { /* native power save case */
\r
1106 ps_tdma_byte0_val = 0x61; /* no null-pkt */
\r
1107 ps_tdma_byte3_val = 0x11; /* no tx-pause at BT-slot */
\r
1108 ps_tdma_byte4_val =
\r
1109 0x11; /* 0x778 = d/1 toggle, no dynamic slot */
\r
1110 /* psTdmaByte4Va is not defne for 0x778 = d/1, 1/1 case */
\r
1113 /* if (bt_link_info->slave_role == true) */
\r
1114 if ((bt_link_info->slave_role == true) && (bt_link_info->a2dp_exist))
\r
1115 ps_tdma_byte4_val = ps_tdma_byte4_val |
\r
1116 0x1; /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
\r
1119 ps_tdma_byte0_val = ps_tdma_byte0_val |
\r
1120 0x82; /* set antenna control by SW */
\r
1121 ps_tdma_byte3_val = ps_tdma_byte3_val |
\r
1122 0x60; /* set antenna no toggle, control by antenna diversity */
\r
1129 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
\r
1130 0x1a, 0x1a, 0x0, ps_tdma_byte4_val);
\r
1133 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1134 ps_tdma_byte0_val, 0x3a +
\r
1135 wifi_duration_adjust, 0x03,
\r
1136 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1139 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1140 ps_tdma_byte0_val, 0x2d +
\r
1141 wifi_duration_adjust, 0x03,
\r
1142 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1145 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1146 ps_tdma_byte0_val, 0x30, 0x03,
\r
1147 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1150 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
\r
1151 0x15, 0x3, 0x14, 0x0);
\r
1154 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1155 ps_tdma_byte0_val, 0x1f, 0x3,
\r
1156 ps_tdma_byte3_val, 0x11);
\r
1159 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1160 ps_tdma_byte0_val, 0x20, 0x3,
\r
1161 ps_tdma_byte3_val, 0x11);
\r
1164 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x13,
\r
1165 0xc, 0x5, 0x0, 0x0);
\r
1168 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
\r
1169 0x25, 0x3, 0x10, 0x0);
\r
1172 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1173 ps_tdma_byte0_val, 0x21, 0x3,
\r
1174 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1177 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x13,
\r
1178 0xa, 0xa, 0x0, 0x40);
\r
1181 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1182 ps_tdma_byte0_val, 0x21, 0x03,
\r
1183 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1186 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
\r
1187 0x0a, 0x0a, 0x0, 0x50);
\r
1190 if (coex_sta->scan_ap_num <= 3)
\r
1191 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1192 ps_tdma_byte0_val, 0x40, 0x3,
\r
1193 ps_tdma_byte3_val,
\r
1194 ps_tdma_byte4_val);
\r
1196 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1197 ps_tdma_byte0_val, 0x21, 0x3,
\r
1198 ps_tdma_byte3_val,
\r
1199 ps_tdma_byte4_val);
\r
1202 if (coex_sta->scan_ap_num <= 3)
\r
1203 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1204 0x51, 0x30, 0x3, 0x10, 0x50);
\r
1206 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1207 ps_tdma_byte0_val, 0x21, 0x3,
\r
1208 ps_tdma_byte3_val,
\r
1209 ps_tdma_byte4_val);
\r
1212 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x13,
\r
1213 0xa, 0x3, 0x8, 0x0);
\r
1216 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
\r
1217 0x15, 0x3, 0x10, 0x0);
\r
1220 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
\r
1221 0x25, 0x3, 0x10, 0x0);
\r
1224 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1225 ps_tdma_byte0_val, 0x3f, 0x03,
\r
1226 ps_tdma_byte3_val, 0x10);
\r
1229 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x61,
\r
1230 0x25, 0x03, 0x11, 0x11);
\r
1233 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1234 ps_tdma_byte0_val, 0x25, 0x03,
\r
1235 ps_tdma_byte3_val, 0x10);
\r
1238 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
\r
1239 0x25, 0x3, 0x31, 0x18);
\r
1242 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
\r
1243 0x15, 0x3, 0x31, 0x18);
\r
1246 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
\r
1247 0xa, 0x3, 0x31, 0x18);
\r
1250 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
\r
1251 0xa, 0x3, 0x31, 0x18);
\r
1254 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
\r
1255 0x25, 0x3, 0x31, 0x98);
\r
1258 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x69,
\r
1259 0x25, 0x3, 0x31, 0x0);
\r
1262 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xab,
\r
1263 0x1a, 0x1a, 0x1, 0x10);
\r
1266 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
\r
1267 0x30, 0x3, 0x10, 0x10);
\r
1270 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xd3,
\r
1271 0x1a, 0x1a, 0, 0x58);
\r
1274 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1275 ps_tdma_byte0_val, 0x35, 0x3,
\r
1276 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1279 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1280 ps_tdma_byte0_val, 0x35, 0x3,
\r
1281 ps_tdma_byte3_val, 0x10);
\r
1284 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x53,
\r
1285 0x1a, 0x1a, 0x0, 0x10);
\r
1288 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x63,
\r
1289 0x1a, 0x1a, 0x0, 0x10);
\r
1292 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xd3,
\r
1293 0x12, 0x3, 0x14, 0x50);
\r
1295 case 40: /* SoftAP only with no sta associated,BT disable ,TDMA mode for power saving */
\r
1296 /* here softap mode screen off will cost 70-80mA for phone */
\r
1297 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x23,
\r
1298 0x18, 0x00, 0x10, 0x24);
\r
1301 /* for 1-Ant translate to 2-Ant */
\r
1303 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1304 ps_tdma_byte0_val, 0x3a +
\r
1305 wifi_duration_adjust, 0x03,
\r
1306 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1309 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1310 ps_tdma_byte0_val, 0x2d +
\r
1311 wifi_duration_adjust, 0x03,
\r
1312 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1315 /* halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51, 0x1d, 0x1d, 0x0, ps_tdma_byte4_val); */
\r
1316 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1317 ps_tdma_byte0_val, 0x3a, 0x03,
\r
1318 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1321 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1322 ps_tdma_byte0_val, 0x15, 0x3,
\r
1323 ps_tdma_byte3_val, 0x11);
\r
1326 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1327 ps_tdma_byte0_val, 0x20, 0x3,
\r
1328 ps_tdma_byte3_val, 0x11);
\r
1331 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1332 ps_tdma_byte0_val, 0x21, 0x3,
\r
1333 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1336 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1337 ps_tdma_byte0_val, 0x21, 0x03,
\r
1338 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1341 /* halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51, 0x12, 0x12, 0x0, ps_tdma_byte4_val); */
\r
1342 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1343 ps_tdma_byte0_val, 0x21, 0x3,
\r
1344 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1347 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1348 ps_tdma_byte0_val, 0x21, 0x3,
\r
1349 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1352 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1353 ps_tdma_byte0_val, 0x3f, 0x03,
\r
1354 ps_tdma_byte3_val, 0x10);
\r
1357 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1358 ps_tdma_byte0_val, 0x25, 0x03,
\r
1359 ps_tdma_byte3_val, 0x10);
\r
1362 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1363 ps_tdma_byte0_val, 0x25, 0x03,
\r
1364 ps_tdma_byte3_val, ps_tdma_byte4_val);
\r
1367 halbtc8723b1ant_set_fw_pstdma(btcoexist,
\r
1368 ps_tdma_byte0_val, 0x25, 0x03,
\r
1369 ps_tdma_byte3_val, 0x11);
\r
1375 /* disable PS tdma */
\r
1377 case 8: /* PTA Control */
\r
1378 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x8,
\r
1379 0x0, 0x0, 0x0, 0x0);
\r
1382 default: /* Software control, Antenna at BT side */
\r
1383 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x0,
\r
1384 0x0, 0x0, 0x0, 0x0);
\r
1386 case 1: /* 2-Ant, 0x778=3, antenna control by antenna diversity */
\r
1387 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x0,
\r
1388 0x0, 0x0, 0x48, 0x0);
\r
1392 rssi_adjust_val = 0;
\r
1393 btcoexist->btc_set(btcoexist,
\r
1394 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val);
\r
1396 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
1397 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
\r
1398 btcoexist->btc_read_4byte(btcoexist, 0x948),
\r
1399 btcoexist->btc_read_1byte(btcoexist, 0x765),
\r
1400 btcoexist->btc_read_1byte(btcoexist, 0x67));
\r
1401 BTC_TRACE(trace_buf);
\r
1403 /* update pre state */
\r
1404 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
\r
1405 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
\r
1408 void halbtc8723b1ant_tdma_duration_adjust_for_acl(IN struct btc_coexist
\r
1409 *btcoexist, IN u8 wifi_status)
\r
1411 static s32 up, dn, m, n, wait_count;
\r
1412 s32 result; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
\r
1413 u8 retry_count = 0, bt_info_ext;
\r
1414 boolean wifi_busy = false;
\r
1416 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY == wifi_status)
\r
1419 wifi_busy = false;
\r
1421 if ((BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN ==
\r
1423 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN == wifi_status) ||
\r
1424 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIFIC_PKT ==
\r
1426 if (coex_dm->cur_ps_tdma != 1 &&
\r
1427 coex_dm->cur_ps_tdma != 2 &&
\r
1428 coex_dm->cur_ps_tdma != 3 &&
\r
1429 coex_dm->cur_ps_tdma != 9) {
\r
1430 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1432 coex_dm->ps_tdma_du_adj_type = 9;
\r
1444 if (!coex_dm->auto_tdma_adjust) {
\r
1445 coex_dm->auto_tdma_adjust = true;
\r
1447 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
\r
1448 coex_dm->ps_tdma_du_adj_type = 2;
\r
1449 /* ============ */
\r
1457 /* accquire the BT TRx retry count from BT_Info byte2 */
\r
1458 retry_count = coex_sta->bt_retry_cnt;
\r
1459 bt_info_ext = coex_sta->bt_info_ext;
\r
1461 if ((coex_sta->low_priority_tx) > 1050 ||
\r
1462 (coex_sta->low_priority_rx) > 1250)
\r
1468 if (retry_count ==
\r
1469 0) { /* no retry in the last 2-second duration */
\r
1476 if (up >= n) { /* if retry count during continuous n*2 seconds is 0, enlarge WiFi duration */
\r
1483 } else if (retry_count <=
\r
1484 3) { /* <=3 retry in the last 2-second duration */
\r
1491 if (dn == 2) { /* if continuous 2 retry count(every 2 seconds) >0 and < 3, reduce WiFi duration */
\r
1492 if (wait_count <= 2)
\r
1493 m++; /* to avoid loop between the two levels */
\r
1497 if (m >= 20) /* maximum of m = 20 ' will recheck if need to adjust wifi duration in maximum time interval 120 seconds */
\r
1506 } else { /* retry count > 3, once retry count > 3, to reduce WiFi duration */
\r
1507 if (wait_count == 1)
\r
1508 m++; /* to avoid loop between the two levels */
\r
1512 if (m >= 20) /* maximum of m = 20 ' will recheck if need to adjust wifi duration in maximum time interval 120 seconds */
\r
1522 if (result == -1) {
\r
1523 /* if( (BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext)) &&
\r
1524 ((coex_dm->cur_ps_tdma == 1) ||(coex_dm->cur_ps_tdma == 2)) )
\r
1526 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
\r
1527 coex_dm->ps_tdma_du_adj_type = 9;
\r
1529 else */ if (coex_dm->cur_ps_tdma == 1) {
\r
1530 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
\r
1532 coex_dm->ps_tdma_du_adj_type = 2;
\r
1533 } else if (coex_dm->cur_ps_tdma == 2) {
\r
1534 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
\r
1536 coex_dm->ps_tdma_du_adj_type = 9;
\r
1537 } else if (coex_dm->cur_ps_tdma == 9) {
\r
1538 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
\r
1540 coex_dm->ps_tdma_du_adj_type = 11;
\r
1542 } else if (result == 1) {
\r
1543 /* if( (BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext)) &&
\r
1544 ((coex_dm->cur_ps_tdma == 1) ||(coex_dm->cur_ps_tdma == 2)) )
\r
1546 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
\r
1547 coex_dm->ps_tdma_du_adj_type = 9;
\r
1549 else */ if (coex_dm->cur_ps_tdma == 11) {
\r
1550 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
\r
1552 coex_dm->ps_tdma_du_adj_type = 9;
\r
1553 } else if (coex_dm->cur_ps_tdma == 9) {
\r
1554 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
\r
1556 coex_dm->ps_tdma_du_adj_type = 2;
\r
1557 } else if (coex_dm->cur_ps_tdma == 2) {
\r
1558 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
\r
1560 coex_dm->ps_tdma_du_adj_type = 1;
\r
1562 } else { /* no change */
\r
1564 if(wifi_busy != pre_wifi_busy)
\r
1566 pre_wifi_busy = wifi_busy;
\r
1567 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, true, coex_dm->cur_ps_tdma);
\r
1573 if (coex_dm->cur_ps_tdma != 1 &&
\r
1574 coex_dm->cur_ps_tdma != 2 &&
\r
1575 coex_dm->cur_ps_tdma != 9 &&
\r
1576 coex_dm->cur_ps_tdma != 11) {
\r
1577 /* recover to previous adjust type */
\r
1578 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1579 coex_dm->ps_tdma_du_adj_type);
\r
1584 void halbtc8723b1ant_ps_tdma_check_for_power_save_state(
\r
1585 IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
\r
1587 u8 lps_mode = 0x0;
\r
1589 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
\r
1591 if (lps_mode) { /* already under LPS state */
\r
1592 if (new_ps_state) {
\r
1593 /* keep state under LPS, do nothing. */
\r
1595 /* will leave LPS state, turn off psTdma first */
\r
1596 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
\r
1599 } else { /* NO PS state */
\r
1600 if (new_ps_state) {
\r
1601 /* will enter LPS state, turn off psTdma first */
\r
1602 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
\r
1605 /* keep state under NO PS state, do nothing. */
\r
1610 void halbtc8723b1ant_power_save_state(IN struct btc_coexist *btcoexist,
\r
1611 IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
\r
1613 boolean low_pwr_disable = false;
\r
1615 switch (ps_type) {
\r
1616 case BTC_PS_WIFI_NATIVE:
\r
1617 /* recover to original 32k low power setting */
\r
1618 low_pwr_disable = false;
\r
1619 btcoexist->btc_set(btcoexist,
\r
1620 BTC_SET_ACT_DISABLE_LOW_POWER,
\r
1621 &low_pwr_disable);
\r
1622 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
\r
1624 coex_sta->force_lps_on = false;
\r
1626 case BTC_PS_LPS_ON:
\r
1627 halbtc8723b1ant_ps_tdma_check_for_power_save_state(
\r
1629 halbtc8723b1ant_lps_rpwm(btcoexist, NORMAL_EXEC,
\r
1630 lps_val, rpwm_val);
\r
1631 /* when coex force to enter LPS, do not enter 32k low power. */
\r
1632 low_pwr_disable = true;
\r
1633 btcoexist->btc_set(btcoexist,
\r
1634 BTC_SET_ACT_DISABLE_LOW_POWER,
\r
1635 &low_pwr_disable);
\r
1636 /* power save must executed before psTdma. */
\r
1637 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
\r
1639 coex_sta->force_lps_on = true;
\r
1641 case BTC_PS_LPS_OFF:
\r
1642 halbtc8723b1ant_ps_tdma_check_for_power_save_state(
\r
1643 btcoexist, false);
\r
1644 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
\r
1646 coex_sta->force_lps_on = false;
\r
1653 void halbtc8723b1ant_action_wifi_only(IN struct btc_coexist *btcoexist)
\r
1655 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
\r
1656 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
\r
1657 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, FORCE_EXEC,
\r
1661 void halbtc8723b1ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
\r
1663 static u32 bt_disable_cnt = 0;
\r
1664 boolean bt_active = true, bt_disabled = false;
\r
1666 /* This function check if bt is disabled */
\r
1668 if (coex_sta->high_priority_tx == 0 &&
\r
1669 coex_sta->high_priority_rx == 0 &&
\r
1670 coex_sta->low_priority_tx == 0 &&
\r
1671 coex_sta->low_priority_rx == 0)
\r
1672 bt_active = false;
\r
1673 if (coex_sta->high_priority_tx == 0xffff &&
\r
1674 coex_sta->high_priority_rx == 0xffff &&
\r
1675 coex_sta->low_priority_tx == 0xffff &&
\r
1676 coex_sta->low_priority_rx == 0xffff)
\r
1677 bt_active = false;
\r
1679 bt_disable_cnt = 0;
\r
1680 bt_disabled = false;
\r
1683 if (bt_disable_cnt >= 2)
\r
1684 bt_disabled = true;
\r
1686 if (coex_sta->bt_disabled != bt_disabled) {
\r
1687 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
1688 "[BTCoex], BT is from %s to %s!!\n",
\r
1689 (coex_sta->bt_disabled ? "disabled" : "enabled"),
\r
1690 (bt_disabled ? "disabled" : "enabled"));
\r
1691 BTC_TRACE(trace_buf);
\r
1693 coex_sta->bt_disabled = bt_disabled;
\r
1694 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
\r
1696 if (bt_disabled) {
\r
1697 halbtc8723b1ant_action_wifi_only(btcoexist);
\r
1698 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
\r
1700 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
\r
1706 /* *********************************************
\r
1708 * Non-Software Coex Mechanism start
\r
1710 * ********************************************* */
\r
1711 void halbtc8723b1ant_action_bt_whck_test(IN struct btc_coexist *btcoexist)
\r
1713 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
1716 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1717 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
\r
1719 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
\r
1722 void halbtc8723b1ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
\r
1724 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
1727 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1728 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
\r
1730 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
\r
1733 void halbtc8723b1ant_action_hs(IN struct btc_coexist *btcoexist)
\r
1735 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
\r
1736 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
\r
1739 void halbtc8723b1ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
\r
1741 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1742 boolean wifi_connected = false, ap_enable = false, wifi_busy = false,
\r
1745 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
\r
1747 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
1749 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
1750 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
\r
1752 if (coex_sta->bt_abnormal_scan) {
\r
1753 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1755 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
\r
1756 } else if ((!wifi_connected) && (!coex_sta->wifi_is_high_pri_task)) {
\r
1757 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
1759 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1760 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
1761 NORMAL_EXEC, false, false);
\r
1762 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
\r
1763 } else if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
\r
1764 (bt_link_info->a2dp_exist)) {
\r
1765 /* SCO/HID/A2DP busy */
\r
1766 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
1769 if (coex_sta->c2h_bt_remote_name_req)
\r
1770 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1773 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1776 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
1777 } else if ((bt_link_info->pan_exist) || (wifi_busy)) {
\r
1778 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
1781 if (coex_sta->c2h_bt_remote_name_req)
\r
1782 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1785 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1788 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
1790 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
1793 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1794 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
1795 NORMAL_EXEC, false, false);
\r
1796 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
\r
1801 void halbtc8723b1ant_action_bt_sco_hid_only_busy(IN struct btc_coexist
\r
1802 *btcoexist, IN u8 wifi_status)
\r
1804 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1805 boolean wifi_connected = false;
\r
1807 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
1810 /* tdma and coex table */
\r
1812 if (bt_link_info->sco_exist) {
\r
1813 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
\r
1814 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
\r
1815 } else { /* HID */
\r
1816 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
\r
1817 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
\r
1821 void halbtc8723b1ant_action_wifi_connected_bt_acl_busy(IN struct btc_coexist
\r
1822 *btcoexist, IN u8 wifi_status)
\r
1824 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1826 if ((coex_sta->low_priority_rx >= 950) && (!coex_sta->under_ips))
\r
1827 bt_link_info->slave_role = true;
\r
1829 bt_link_info->slave_role = false;
\r
1831 if (bt_link_info->hid_only) { /* HID */
\r
1832 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
\r
1834 coex_dm->auto_tdma_adjust = false;
\r
1836 } else if (bt_link_info->a2dp_only) { /* A2DP */
\r
1837 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE == wifi_status) {
\r
1838 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1840 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1842 coex_dm->auto_tdma_adjust = false;
\r
1844 halbtc8723b1ant_tdma_duration_adjust_for_acl(btcoexist,
\r
1846 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1848 coex_dm->auto_tdma_adjust = true;
\r
1850 } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
\r
1851 (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
\r
1852 bt_link_info->pan_exist)) { /* A2DP+PAN(OPP,FTP), HID+A2DP+PAN(OPP,FTP) */
\r
1853 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
\r
1854 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
1855 coex_dm->auto_tdma_adjust = false;
\r
1856 } else if (bt_link_info->hid_exist &&
\r
1857 bt_link_info->a2dp_exist) { /* HID+A2DP */
\r
1858 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
\r
1859 coex_dm->auto_tdma_adjust = false;
\r
1861 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
1862 } else if ((bt_link_info->pan_only) || (bt_link_info->hid_exist &&
\r
1863 bt_link_info->pan_exist)) { /* PAN(OPP,FTP), HID+PAN(OPP,FTP) */
\r
1864 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
\r
1865 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
1866 coex_dm->auto_tdma_adjust = false;
\r
1868 /* BT no-profile busy (0x9) */
\r
1869 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
\r
1870 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
1871 coex_dm->auto_tdma_adjust = false;
\r
1875 void halbtc8723b1ant_action_wifi_not_connected(IN struct btc_coexist *btcoexist)
\r
1877 /* power save state */
\r
1878 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
1881 /* tdma and coex table */
\r
1882 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
\r
1883 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
\r
1885 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
\r
1888 void halbtc8723b1ant_action_wifi_not_connected_scan(IN struct btc_coexist
\r
1891 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1893 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
1896 /* tdma and coex table */
\r
1897 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
\r
1898 if (bt_link_info->a2dp_exist) {
\r
1899 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1901 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1903 } else if (bt_link_info->a2dp_exist &&
\r
1904 bt_link_info->pan_exist) {
\r
1905 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1907 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1910 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1912 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1915 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
\r
1916 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
\r
1917 coex_dm->bt_status)) {
\r
1918 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
\r
1919 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
\r
1922 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1923 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
1924 NORMAL_EXEC, false, false);
\r
1925 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
\r
1929 void halbtc8723b1ant_action_wifi_not_connected_asso_auth(
\r
1930 IN struct btc_coexist *btcoexist)
\r
1932 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1934 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
1937 /* tdma and coex table */
\r
1938 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
\r
1939 (bt_link_info->a2dp_exist)) {
\r
1940 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
\r
1941 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
\r
1942 } else if (bt_link_info->pan_exist) {
\r
1943 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
\r
1944 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
\r
1946 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1947 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
1948 NORMAL_EXEC, false, false);
\r
1949 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
\r
1953 void halbtc8723b1ant_action_wifi_connected_scan(IN struct btc_coexist
\r
1956 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1958 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
1961 /* tdma and coex table */
\r
1962 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
\r
1963 if (bt_link_info->a2dp_exist) {
\r
1964 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1966 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1968 } else if (bt_link_info->a2dp_exist &&
\r
1969 bt_link_info->pan_exist) {
\r
1970 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1972 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1975 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
1977 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
1980 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
\r
1981 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
\r
1982 coex_dm->bt_status)) {
\r
1983 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
\r
1984 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
\r
1987 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
1988 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
1989 NORMAL_EXEC, false, false);
\r
1990 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
\r
1994 void halbtc8723b1ant_action_wifi_connected_specific_packet(
\r
1995 IN struct btc_coexist *btcoexist)
\r
1997 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
1998 boolean wifi_busy = false;
\r
2000 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
2002 /* no specific packet process for both WiFi and BT very busy */
\r
2003 if ((wifi_busy) && ((bt_link_info->pan_exist) ||
\r
2004 (coex_sta->num_of_profile >= 2)))
\r
2007 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
2010 /* tdma and coex table */
\r
2011 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
\r
2012 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
\r
2013 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
\r
2014 } else if (bt_link_info->a2dp_exist) {
\r
2015 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
\r
2016 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
2017 } else if (bt_link_info->pan_exist) {
\r
2018 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
\r
2019 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
\r
2021 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
\r
2022 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
2023 NORMAL_EXEC, false, false);
\r
2024 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
\r
2028 void halbtc8723b1ant_action_wifi_connected(IN struct btc_coexist *btcoexist)
\r
2030 boolean wifi_busy = false;
\r
2031 boolean scan = false, link = false, roam = false;
\r
2032 boolean under_4way = false, ap_enable = false;
\r
2034 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2035 "[BTCoex], CoexForWifiConnect()===>\n");
\r
2036 BTC_TRACE(trace_buf);
\r
2038 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
\r
2041 halbtc8723b1ant_action_wifi_connected_specific_packet(btcoexist);
\r
2042 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2043 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
\r
2044 BTC_TRACE(trace_buf);
\r
2048 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
\r
2049 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
\r
2050 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
\r
2051 if (scan || link || roam) {
\r
2053 halbtc8723b1ant_action_wifi_connected_scan(btcoexist);
\r
2055 halbtc8723b1ant_action_wifi_connected_specific_packet(
\r
2057 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2058 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
\r
2059 BTC_TRACE(trace_buf);
\r
2063 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
\r
2065 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
2067 /* power save state */
\r
2069 BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status &&
\r
2070 !btcoexist->bt_link_info.hid_only) {
\r
2071 if (btcoexist->bt_link_info.a2dp_only) { /* A2DP */
\r
2073 halbtc8723b1ant_power_save_state(btcoexist,
\r
2074 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
\r
2076 if (coex_sta->scan_ap_num >=
\r
2077 BT_8723B_1ANT_WIFI_NOISY_THRESH) /* no force LPS, no PS-TDMA, use pure TDMA */
\r
2078 halbtc8723b1ant_power_save_state(
\r
2079 btcoexist, BTC_PS_WIFI_NATIVE,
\r
2082 halbtc8723b1ant_power_save_state(
\r
2083 btcoexist, BTC_PS_LPS_ON, 0x50,
\r
2086 } else if ((coex_sta->pan_exist == false) &&
\r
2087 (coex_sta->a2dp_exist == false) &&
\r
2088 (coex_sta->hid_exist == false))
\r
2089 halbtc8723b1ant_power_save_state(btcoexist,
\r
2090 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
\r
2092 halbtc8723b1ant_power_save_state(btcoexist,
\r
2093 BTC_PS_LPS_ON, 0x50, 0x4);
\r
2095 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
2098 /* tdma and coex table */
\r
2100 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
\r
2101 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
\r
2103 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
\r
2104 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY ==
\r
2105 coex_dm->bt_status) ||
\r
2106 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
\r
2107 coex_dm->bt_status)) {
\r
2108 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
\r
2109 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
\r
2111 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
\r
2113 halbtc8723b1ant_set_ant_path(btcoexist,
\r
2114 BTC_ANT_PATH_PTA, NORMAL_EXEC, false, false);
\r
2115 /* if ((coex_sta->high_priority_tx) +
\r
2116 (coex_sta->high_priority_rx) <= 60) */
\r
2117 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
2120 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
2121 NORMAL_EXEC, 7); */
\r
2124 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
\r
2125 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
\r
2127 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
\r
2128 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY ==
\r
2129 coex_dm->bt_status) ||
\r
2130 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
\r
2131 coex_dm->bt_status)) {
\r
2132 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
\r
2133 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
\r
2135 /* halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
\r
2137 halbtc8723b1ant_set_ant_path(btcoexist,
\r
2138 BTC_ANT_PATH_PTA, NORMAL_EXEC, false, false);
\r
2139 if ((coex_sta->high_priority_tx) +
\r
2140 (coex_sta->high_priority_rx) <= 60)
\r
2141 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
2144 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
2145 NORMAL_EXEC, 7); */
\r
2146 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
\r
2148 halbtc8723b1ant_set_ant_path(btcoexist,
\r
2149 BTC_ANT_PATH_PTA, NORMAL_EXEC, false, false);
\r
2150 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
2157 void halbtc8723b1ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
\r
2159 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
2160 boolean wifi_connected = false, bt_hs_on = false, wifi_busy = false;
\r
2161 boolean increase_scan_dev_num = false;
\r
2162 boolean bt_ctrl_agg_buf_size = false;
\r
2163 boolean miracast_plus_bt = false;
\r
2164 u8 agg_buf_size = 5;
\r
2165 u32 wifi_link_status = 0;
\r
2166 u32 num_of_wifi_link = 0, wifi_bw;
\r
2167 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
\r
2169 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2170 "[BTCoex], RunCoexistMechanism()===>\n");
\r
2171 BTC_TRACE(trace_buf);
\r
2173 if (btcoexist->manual_control) {
\r
2174 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2175 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
\r
2176 BTC_TRACE(trace_buf);
\r
2180 if (btcoexist->stop_coex_dm) {
\r
2181 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2182 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
\r
2183 BTC_TRACE(trace_buf);
\r
2187 if (coex_sta->under_ips) {
\r
2188 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2189 "[BTCoex], wifi is under IPS !!!\n");
\r
2190 BTC_TRACE(trace_buf);
\r
2194 if (coex_sta->bt_whck_test) {
\r
2195 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2196 "[BTCoex], BT is under WHCK TEST!!!\n");
\r
2197 BTC_TRACE(trace_buf);
\r
2198 halbtc8723b1ant_action_bt_whck_test(btcoexist);
\r
2202 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
\r
2203 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
\r
2204 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
\r
2205 increase_scan_dev_num = true;
\r
2207 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
\r
2208 &increase_scan_dev_num);
\r
2209 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
2211 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
\r
2213 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
\r
2214 &wifi_link_status);
\r
2215 num_of_wifi_link = wifi_link_status >> 16;
\r
2217 if ((num_of_wifi_link >= 2) ||
\r
2218 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
\r
2219 if (bt_link_info->bt_link_exist) {
\r
2220 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1,
\r
2222 miracast_plus_bt = true;
\r
2224 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0,
\r
2226 miracast_plus_bt = false;
\r
2228 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
\r
2229 &miracast_plus_bt);
\r
2230 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
\r
2231 bt_ctrl_agg_buf_size, agg_buf_size);
\r
2233 if (((bt_link_info->a2dp_exist) || (wifi_busy)) &&
\r
2234 (coex_sta->c2h_bt_inquiry_page))
\r
2235 halbtc8723b1ant_action_bt_inquiry(btcoexist);
\r
2237 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
\r
2241 miracast_plus_bt = false;
\r
2242 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
\r
2243 &miracast_plus_bt);
\r
2246 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
\r
2248 if ((bt_link_info->bt_link_exist) && (wifi_connected)) {
\r
2249 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 0, 1);
\r
2251 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
\r
2253 /* if(BTC_IOT_PEER_CISCO != iot_peer) */
\r
2254 if ((BTC_IOT_PEER_CISCO != iot_peer) &&
\r
2255 (BTC_IOT_PEER_BROADCOM != iot_peer)) {
\r
2256 if (bt_link_info->sco_exist) /* if (bt_link_info->bt_hi_pri_link_exist) */
\r
2257 /* halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, true, false, 0x5); */
\r
2258 halbtc8723b1ant_limited_rx(btcoexist,
\r
2259 NORMAL_EXEC, false, false, 0x5);
\r
2261 halbtc8723b1ant_limited_rx(btcoexist,
\r
2262 NORMAL_EXEC, false, false, 0x5);
\r
2263 /* halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x8); */
\r
2265 if (bt_link_info->sco_exist)
\r
2266 halbtc8723b1ant_limited_rx(btcoexist,
\r
2267 NORMAL_EXEC, true, false, 0x5);
\r
2269 if (BTC_WIFI_BW_HT40 == wifi_bw)
\r
2270 halbtc8723b1ant_limited_rx(btcoexist,
\r
2271 NORMAL_EXEC, false, true, 0x10);
\r
2273 halbtc8723b1ant_limited_rx(btcoexist,
\r
2274 NORMAL_EXEC, false, true, 0x8);
\r
2278 halbtc8723b1ant_sw_mechanism(btcoexist, true);
\r
2280 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
\r
2282 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
\r
2285 halbtc8723b1ant_sw_mechanism(btcoexist, false);
\r
2288 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
\r
2289 if (coex_sta->c2h_bt_inquiry_page) {
\r
2290 halbtc8723b1ant_action_bt_inquiry(btcoexist);
\r
2292 } else if (bt_hs_on) {
\r
2293 halbtc8723b1ant_action_hs(btcoexist);
\r
2298 if (!wifi_connected) {
\r
2299 boolean scan = false, link = false, roam = false;
\r
2301 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2302 "[BTCoex], wifi is non connected-idle !!!\n");
\r
2303 BTC_TRACE(trace_buf);
\r
2305 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
\r
2306 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
\r
2307 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
\r
2309 if (scan || link || roam) {
\r
2311 halbtc8723b1ant_action_wifi_not_connected_scan(
\r
2314 halbtc8723b1ant_action_wifi_not_connected_asso_auth(
\r
2317 halbtc8723b1ant_action_wifi_not_connected(btcoexist);
\r
2318 } else /* wifi LPS/Busy */
\r
2319 halbtc8723b1ant_action_wifi_connected(btcoexist);
\r
2322 void halbtc8723b1ant_init_coex_dm(IN struct btc_coexist *btcoexist)
\r
2324 /* force to reset coex mechanism */
\r
2327 halbtc8723b1ant_sw_mechanism(btcoexist, false);
\r
2329 /* halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); */
\r
2330 /* halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0); */
\r
2332 coex_sta->pop_event_cnt = 0;
\r
2335 void halbtc8723b1ant_init_hw_config(IN struct btc_coexist *btcoexist,
\r
2336 IN boolean back_up, IN boolean wifi_only)
\r
2338 u32 u32tmp = 0; /* , fw_ver; */
\r
2339 u8 u8tmpa = 0, u8tmpb = 0;
\r
2341 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2342 "[BTCoex], 1Ant Init HW Config!!\n");
\r
2343 BTC_TRACE(trace_buf);
\r
2345 psd_scan->ant_det_is_ant_det_available = false;
\r
2347 /* 0xf0[15:12] --> Chip Cut information */
\r
2348 coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
\r
2349 0xf1) & 0xf0) >> 4;
\r
2351 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
\r
2352 0x1); /* enable TBTT nterrupt */
\r
2354 /* 0x790[5:0]=0x5 */
\r
2355 btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
\r
2357 /* Enable counter statistics */
\r
2358 /* btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); //0x76e[3] =1, WLAN_Act control by PTA */
\r
2359 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
\r
2360 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
\r
2363 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1); //BT select s0/s1 is controlled by WiFi */
\r
2365 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
\r
2367 /* Antenna config */
\r
2369 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
\r
2370 FORCE_EXEC, true, false);
\r
2372 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
\r
2373 FORCE_EXEC, true, false);
\r
2375 /* PTA parameter */
\r
2376 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
\r
2378 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
\r
2379 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
\r
2380 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
\r
2382 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2383 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
\r
2384 u32tmp, u8tmpa, u8tmpb);
\r
2385 BTC_TRACE(trace_buf);
\r
2388 void halbtc8723b1ant_mechanism_switch(IN struct btc_coexist *btcoexist,
\r
2389 IN boolean bSwitchTo2Antenna)
\r
2392 if (bSwitchTo2Antenna) { /* 1-Ant -> 2-Ant */
\r
2393 /* un-lock TRx Mask setup for 8723b f-cut */
\r
2394 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd, 0x80, 0x1);
\r
2395 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf, 0x1, 0x1);
\r
2396 /* WiFi TRx Mask on */
\r
2397 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
\r
2400 /* BT TRx Mask un-lock 0x2c[0], 0x30[0] = 1 */
\r
2401 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x2c,
\r
2403 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x30,
\r
2406 /* BT TRx Mask on */
\r
2407 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x1);
\r
2409 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
\r
2410 FORCE_EXEC, false, false);
\r
2412 /* WiFi TRx Mask on */
\r
2413 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
\r
2416 /* lock TRx Mask setup for 8723b f-cut */
\r
2417 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd, 0x80, 0x0);
\r
2418 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf, 0x1, 0x0);
\r
2420 /* BT TRx Mask on */
\r
2421 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x15);
\r
2423 /* BT TRx Mask ock 0x2c[0], 0x30[0] = 0 */
\r
2424 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x2c,
\r
2426 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x30,
\r
2430 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
2431 FORCE_EXEC, false, false);
\r
2436 u32 halbtc8723b1ant_psd_log2base(IN struct btc_coexist *btcoexist, IN u32 val)
\r
2439 u32 tmp, tmp2, val_integerd_b = 0, tindex, shiftcount = 0;
\r
2440 u32 result, val_fractiond_b = 0, table_fraction[21] = {0, 432, 332, 274, 232, 200,
\r
2441 174, 151, 132, 115, 100, 86, 74, 62, 51, 42,
\r
2460 val_integerd_b = shiftcount + 1;
\r
2463 for (j = 1; j <= val_integerd_b; j++)
\r
2466 tmp = (val * 100) / tmp2;
\r
2472 val_fractiond_b = table_fraction[tindex];
\r
2474 result = val_integerd_b * 100 - val_fractiond_b;
\r
2481 void halbtc8723b1ant_psd_show_antenna_detect_result(IN struct btc_coexist
\r
2484 u8 *cli_buf = btcoexist->cli_buf;
\r
2485 struct btc_board_info *board_info = &btcoexist->board_info;
\r
2487 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2488 "\r\n============[Antenna Detection info] ============\n");
\r
2489 CL_PRINTF(cli_buf);
\r
2491 if (psd_scan->ant_det_result == 1)
\r
2492 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (>%d)",
\r
2493 "Ant Det Result", "2-Antenna (Bad-Isolation)",
\r
2494 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
\r
2495 else if (psd_scan->ant_det_result == 2)
\r
2496 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
\r
2497 "Ant Det Result", "2-Antenna (Good-Isolation)",
\r
2498 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
\r
2499 + psd_scan->ant_det_thres_offset,
\r
2500 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
\r
2502 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
\r
2503 "Ant Det Result", "1-Antenna",
\r
2504 BT_8723B_1ANT_ANTDET_PSDTHRES_1ANT,
\r
2505 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
\r
2506 + psd_scan->ant_det_thres_offset);
\r
2508 CL_PRINTF(cli_buf);
\r
2510 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s ",
\r
2511 "Antenna Detection Finish",
\r
2512 (board_info->btdm_ant_det_finish
\r
2514 CL_PRINTF(cli_buf);
\r
2516 switch (psd_scan->ant_det_result) {
\r
2518 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2519 "(BT is not available)");
\r
2521 case 1: /* 2-Ant bad-isolation */
\r
2522 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2523 "(BT is available)");
\r
2525 case 2: /* 2-Ant good-isolation */
\r
2526 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2527 "(BT is available)");
\r
2529 case 3: /* 1-Ant */
\r
2530 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2531 "(BT is available)");
\r
2534 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2535 "(Uncertainty result)");
\r
2538 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "(Pre-Scan fai)");
\r
2541 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2542 "(WiFi is Scanning)");
\r
2545 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2546 "(BT is not idle)");
\r
2549 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2550 "(Abort by WiFi Scanning)");
\r
2553 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2554 "(Antenna Init is not ready)");
\r
2557 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2558 "(BT is Inquiry or page)");
\r
2561 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2562 "(BT is Disabled)");
\r
2565 CL_PRINTF(cli_buf);
\r
2568 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
\r
2569 "Ant Detect Total Count", psd_scan->ant_det_try_count);
\r
2570 CL_PRINTF(cli_buf);
\r
2572 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
\r
2573 "Ant Detect Fail Count", psd_scan->ant_det_fail_count);
\r
2574 CL_PRINTF(cli_buf);
\r
2576 if ((!board_info->btdm_ant_det_finish) &&
\r
2577 (psd_scan->ant_det_result != 5))
\r
2580 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT Response",
\r
2581 (psd_scan->ant_det_result ? "ok" : "fail"));
\r
2582 CL_PRINTF(cli_buf);
\r
2584 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ms", "BT Tx Time",
\r
2585 psd_scan->ant_det_bt_tx_time);
\r
2586 CL_PRINTF(cli_buf);
\r
2588 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d", "BT Tx Ch",
\r
2589 psd_scan->ant_det_bt_le_channel);
\r
2590 CL_PRINTF(cli_buf);
\r
2592 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
\r
2593 "WiFi PSD Cent-Ch/Offset/Span",
\r
2594 psd_scan->real_cent_freq, psd_scan->real_offset,
\r
2595 psd_scan->real_span);
\r
2596 CL_PRINTF(cli_buf);
\r
2598 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
\r
2599 "PSD Pre-Scan Peak Value",
\r
2600 psd_scan->ant_det_pre_psdscan_peak_val / 100);
\r
2601 CL_PRINTF(cli_buf);
\r
2603 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (<= %d)",
\r
2604 "PSD Pre-Scan result",
\r
2605 (psd_scan->ant_det_result != 5 ? "ok" : "fail"),
\r
2606 BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
\r
2607 + psd_scan->ant_det_thres_offset);
\r
2608 CL_PRINTF(cli_buf);
\r
2610 if (psd_scan->ant_det_result == 5)
\r
2613 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s dB",
\r
2614 "PSD Scan Peak Value", psd_scan->ant_det_peak_val);
\r
2615 CL_PRINTF(cli_buf);
\r
2617 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s MHz",
\r
2618 "PSD Scan Peak Freq", psd_scan->ant_det_peak_freq);
\r
2619 CL_PRINTF(cli_buf);
\r
2622 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "TFBGA Package",
\r
2623 (board_info->tfbga_package) ? "Yes" : "No");
\r
2624 CL_PRINTF(cli_buf);
\r
2626 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
\r
2627 "PSD Threshold Offset", psd_scan->ant_det_thres_offset);
\r
2628 CL_PRINTF(cli_buf);
\r
2632 void halbtc8723b1ant_psd_showdata(IN struct btc_coexist *btcoexist)
\r
2634 u8 *cli_buf = btcoexist->cli_buf;
\r
2635 u32 delta_freq_per_point;
\r
2636 u32 freq, freq1, freq2, n = 0, i = 0, j = 0, m = 0, psd_rep1, psd_rep2;
\r
2638 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2639 "\r\n\n============[PSD info] (%d)============\n",
\r
2640 psd_scan->psd_gen_count);
\r
2641 CL_PRINTF(cli_buf);
\r
2643 if (psd_scan->psd_gen_count == 0) {
\r
2644 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n No data !!\n");
\r
2645 CL_PRINTF(cli_buf);
\r
2649 if (psd_scan->psd_point == 0)
\r
2650 delta_freq_per_point = 0;
\r
2652 delta_freq_per_point = psd_scan->psd_band_width /
\r
2653 psd_scan->psd_point;
\r
2655 /* if (psd_scan->is_psd_show_max_only) */
\r
2657 psd_rep1 = psd_scan->psd_max_value / 100;
\r
2658 psd_rep2 = psd_scan->psd_max_value - psd_rep1 * 100;
\r
2660 freq = ((psd_scan->real_cent_freq - 20) * 1000000 +
\r
2661 psd_scan->psd_max_value_point * delta_freq_per_point);
\r
2662 freq1 = freq / 1000000;
\r
2663 freq2 = freq / 1000 - freq1 * 1000;
\r
2666 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2667 "\r\n Freq = %d.0%d MHz",
\r
2670 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2671 "\r\n Freq = %d.%d MHz",
\r
2674 if (psd_rep2 < 10)
\r
2675 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2676 ", Value = %d.0%d dB, (%d)\n",
\r
2677 psd_rep1, psd_rep2, psd_scan->psd_max_value);
\r
2679 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2680 ", Value = %d.%d dB, (%d)\n",
\r
2681 psd_rep1, psd_rep2, psd_scan->psd_max_value);
\r
2683 CL_PRINTF(cli_buf);
\r
2685 m = psd_scan->psd_start_point;
\r
2686 n = psd_scan->psd_start_point;
\r
2692 freq = ((psd_scan->real_cent_freq - 20) * 1000000 + m *
\r
2693 delta_freq_per_point);
\r
2694 freq1 = freq / 1000000;
\r
2695 freq2 = freq / 1000 - freq1 * 1000;
\r
2699 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2700 "\r\n Freq%6d.000", freq1);
\r
2701 else if (freq2 < 100)
\r
2702 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2703 "\r\n Freq%6d.0%2d", freq1,
\r
2706 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2707 "\r\n Freq%6d.%3d", freq1,
\r
2709 } else if ((i % 8 == 0) ||
\r
2710 (m == psd_scan->psd_stop_point)) {
\r
2712 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2713 "%6d.000\n", freq1);
\r
2714 else if (freq2 < 100)
\r
2715 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2716 "%6d.0%2d\n", freq1, freq2);
\r
2718 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2719 "%6d.%3d\n", freq1, freq2);
\r
2722 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2723 "%6d.000", freq1);
\r
2724 else if (freq2 < 100)
\r
2725 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2726 "%6d.0%2d", freq1, freq2);
\r
2728 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2729 "%6d.%3d", freq1, freq2);
\r
2734 CL_PRINTF(cli_buf);
\r
2736 } while ((i <= 8) && (m <= psd_scan->psd_stop_point));
\r
2740 psd_rep1 = psd_scan->psd_report_max_hold[n] / 100;
\r
2741 psd_rep2 = psd_scan->psd_report_max_hold[n] - psd_rep1 *
\r
2745 if (psd_rep2 < 10)
\r
2746 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2747 "\r\n Val %7d.0%d", psd_rep1,
\r
2750 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2751 "\r\n Val %7d.%d", psd_rep1,
\r
2753 } else if ((j % 8 == 0) ||
\r
2754 (n == psd_scan->psd_stop_point)) {
\r
2755 if (psd_rep2 < 10)
\r
2756 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2757 "%7d.0%d\n", psd_rep1,
\r
2760 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2761 "%7d.%d\n", psd_rep1, psd_rep2);
\r
2763 if (psd_rep2 < 10)
\r
2764 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2765 "%7d.0%d", psd_rep1, psd_rep2);
\r
2767 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
2768 "%7d.%d", psd_rep1, psd_rep2);
\r
2773 CL_PRINTF(cli_buf);
\r
2775 } while ((j <= 8) && (n <= psd_scan->psd_stop_point));
\r
2777 if ((m > psd_scan->psd_stop_point) ||
\r
2778 (n > psd_scan->psd_stop_point))
\r
2791 void halbtc8723b1ant_psd_max_holddata(IN struct btc_coexist *btcoexist,
\r
2794 u32 i = 0, i_max = 0, val_max = 0;
\r
2796 if (gen_count == 1) {
\r
2797 memcpy(psd_scan->psd_report_max_hold,
\r
2798 psd_scan->psd_report,
\r
2799 BT_8723B_1ANT_ANTDET_PSD_POINTS * sizeof(u32));
\r
2801 psd_scan->psd_max_value_point = 0;
\r
2802 psd_scan->psd_max_value = 0;
\r
2805 for (i = psd_scan->psd_start_point;
\r
2806 i <= psd_scan->psd_stop_point; i++) {
\r
2807 if (psd_scan->psd_report[i] >
\r
2808 psd_scan->psd_report_max_hold[i])
\r
2809 psd_scan->psd_report_max_hold[i] =
\r
2810 psd_scan->psd_report[i];
\r
2812 /* search Max Value */
\r
2813 if (i == psd_scan->psd_start_point) {
\r
2815 val_max = psd_scan->psd_report_max_hold[i];
\r
2817 if (psd_scan->psd_report_max_hold[i] >
\r
2820 val_max = psd_scan->psd_report_max_hold[i];
\r
2826 psd_scan->psd_max_value_point = i_max;
\r
2827 psd_scan->psd_max_value = val_max;
\r
2834 u32 halbtc8723b1ant_psd_getdata(IN struct btc_coexist *btcoexist, IN u32 point)
\r
2836 /* reg 0x808[9:0]: FFT data x */
\r
2837 /* reg 0x808[22]: 0-->1 to get 1 FFT data y */
\r
2838 /* reg 0x8b4[15:0]: FFT data y report */
\r
2840 u32 val = 0, psd_report = 0;
\r
2843 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
\r
2845 val &= 0xffbffc00;
\r
2848 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
\r
2850 val |= 0x00400000;
\r
2851 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
\r
2854 if (k++ > BT_8723B_1ANT_ANTDET_SWEEPPOINT_DELAY)
\r
2858 val = btcoexist->btc_read_4byte(btcoexist, 0x8b4);
\r
2860 psd_report = val & 0x0000ffff;
\r
2862 return psd_report;
\r
2866 boolean halbtc8723b1ant_psd_sweep_point(IN struct btc_coexist *btcoexist,
\r
2867 IN u32 cent_freq, IN s32 offset, IN u32 span, IN u32 points,
\r
2868 IN u32 avgnum, IN u32 loopcnt)
\r
2870 u32 i, val, n, k = 0, j, point_index = 0;
\r
2871 u32 points1 = 0, psd_report = 0;
\r
2872 u32 start_p = 0, stop_p = 0, delta_freq_per_point = 156250;
\r
2873 u32 psd_center_freq = 20 * 10 ^ 6;
\r
2874 boolean outloop = false, scan , roam, is_sweep_ok = true;
\r
2877 u32 wifi_original_channel = 1;
\r
2879 psd_scan->is_psd_running = true;
\r
2880 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
2881 "xxxxxxxxxxxxxxxx PSD Sweep Start!!\n");
\r
2882 BTC_TRACE(trace_buf);
\r
2886 case 0: /* Get PSD parameters */
\r
2889 psd_scan->psd_band_width = 40 * 1000000;
\r
2890 psd_scan->psd_point = points;
\r
2891 psd_scan->psd_start_base = points / 2;
\r
2892 psd_scan->psd_avg_num = avgnum;
\r
2893 psd_scan->real_cent_freq = cent_freq;
\r
2894 psd_scan->real_offset = offset;
\r
2895 psd_scan->real_span = span;
\r
2898 points1 = psd_scan->psd_point;
\r
2899 delta_freq_per_point = psd_scan->psd_band_width /
\r
2900 psd_scan->psd_point;
\r
2902 /* PSD point setup */
\r
2903 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
\r
2904 val &= 0xffff0fff;
\r
2906 switch (psd_scan->psd_point) {
\r
2912 val |= 0x00004000;
\r
2915 val |= 0x00008000;
\r
2918 val |= 0x0000c000;
\r
2922 switch (psd_scan->psd_avg_num) {
\r
2927 val |= 0x00001000;
\r
2930 val |= 0x00002000;
\r
2934 val |= 0x00003000;
\r
2937 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
\r
2941 case 1: /* calculate the PSD point index from freq/offset/span */
\r
2942 psd_center_freq = psd_scan->psd_band_width / 2 +
\r
2943 offset * (1000000);
\r
2945 start_p = psd_scan->psd_start_base + (psd_center_freq -
\r
2946 span * (1000000) / 2) / delta_freq_per_point;
\r
2947 psd_scan->psd_start_point = start_p -
\r
2948 psd_scan->psd_start_base;
\r
2950 stop_p = psd_scan->psd_start_base + (psd_center_freq +
\r
2951 span * (1000000) / 2) / delta_freq_per_point;
\r
2952 psd_scan->psd_stop_point = stop_p -
\r
2953 psd_scan->psd_start_base - 1;
\r
2957 case 2: /* set RF channel/BW/Mode */
\r
2959 /* set 3-wire off */
\r
2960 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
\r
2961 val |= 0x00300000;
\r
2962 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
\r
2965 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
\r
2966 val &= 0xfeffffff;
\r
2967 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
\r
2969 /* store WiFi original channel */
\r
2970 wifi_original_channel = btcoexist->btc_get_rf_reg(
\r
2971 btcoexist, BTC_RF_A, 0x18, 0x3ff);
\r
2973 /* Set RF channel */
\r
2974 if (cent_freq == 2484)
\r
2975 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
\r
2976 0x18, 0x3ff, 0xe);
\r
2978 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
\r
2979 0x18, 0x3ff, (cent_freq - 2412) / 5 +
\r
2980 1); /* WiFi TRx Mask on */
\r
2983 /* Set RF Rx filter corner */
\r
2984 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
\r
2987 /* Set TRx mask off */
\r
2988 /* un-lock TRx Mask setup */
\r
2989 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd,
\r
2991 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf,
\r
2994 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
\r
2997 /* Set RF mode = Rx, RF Gain = 0x8a0 */
\r
2998 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x0,
\r
2999 0xfffff, 0x308a0);
\r
3002 if (k++ > BT_8723B_1ANT_ANTDET_SWEEPPOINT_DELAY)
\r
3008 psd_scan->psd_gen_count = 0;
\r
3009 for (j = 1; j <= loopcnt; j++) {
\r
3011 btcoexist->btc_get(btcoexist,
\r
3012 BTC_GET_BL_WIFI_SCAN, &scan);
\r
3013 btcoexist->btc_get(btcoexist,
\r
3014 BTC_GET_BL_WIFI_ROAM, &roam);
\r
3016 if (scan || roam) {
\r
3017 is_sweep_ok = false;
\r
3020 memset(psd_scan->psd_report, 0,
\r
3021 psd_scan->psd_point * sizeof(u32));
\r
3022 start_p = psd_scan->psd_start_point +
\r
3023 psd_scan->psd_start_base;
\r
3024 stop_p = psd_scan->psd_stop_point +
\r
3025 psd_scan->psd_start_base + 1;
\r
3030 while (i < stop_p) {
\r
3033 halbtc8723b1ant_psd_getdata(
\r
3034 btcoexist, i - points1);
\r
3037 halbtc8723b1ant_psd_getdata(
\r
3040 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3041 "Point=%d, psd_raw_data = 0x%08x\n",
\r
3043 BTC_TRACE(trace_buf);
\r
3044 if (psd_report == 0)
\r
3047 /* tmp = 20*log10((double)psd_report); */
\r
3048 /* 20*log2(x)/log2(10), log2Base return theresult of the psd_report*100 */
\r
3049 tmp = 6 * halbtc8723b1ant_psd_log2base(
\r
3050 btcoexist, psd_report);
\r
3052 n = i - psd_scan->psd_start_base;
\r
3053 psd_scan->psd_report[n] = tmp;
\r
3056 halbtc8723b1ant_psd_max_holddata(
\r
3063 psd_scan->psd_gen_count = j;
\r
3068 case 99: /* error */
\r
3072 case 100: /* recovery */
\r
3074 /* set 3-wire on */
\r
3075 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
\r
3076 val &= 0xffcfffff;
\r
3077 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
\r
3080 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
\r
3081 val |= 0x01000000;
\r
3082 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
\r
3085 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
\r
3086 val &= 0xffbfffff;
\r
3087 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
\r
3090 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
\r
3093 /* lock TRx Mask setup */
\r
3094 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd,
\r
3096 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf,
\r
3099 /* Set RF Rx filter corner */
\r
3100 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
\r
3103 /* restore WiFi original channel */
\r
3104 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x18,
\r
3105 0x3ff, wifi_original_channel);
\r
3112 } while (!outloop);
\r
3116 psd_scan->is_psd_running = false;
\r
3118 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3119 "xxxxxxxxxxxxxxxx PSD Sweep Stop!!\n");
\r
3120 BTC_TRACE(trace_buf);
\r
3121 return is_sweep_ok;
\r
3125 void halbtc8723b1ant_psd_antenna_detection(IN struct btc_coexist *btcoexist,
\r
3126 IN u32 bt_tx_time, IN u32 bt_le_channel)
\r
3129 u32 wlpsd_cent_freq = 2484, wlpsd_span = 2, wlpsd_sweep_count = 50;
\r
3130 s32 wlpsd_offset = -4;
\r
3131 u8 bt_le_ch[13] = {3,6,8,11,13,16,18,21,23,26,28,31,33};
\r
3133 u8 h2c_parameter[3] ={0},u8tmpa,u8tmpb;
\r
3136 boolean outloop = false, bt_resp = false;
\r
3137 u32 freq, freq1, freq2, psd_rep1, psd_rep2, delta_freq_per_point,
\r
3139 struct btc_board_info *board_info = &btcoexist->board_info;
\r
3141 board_info->btdm_ant_det_finish = false;
\r
3142 memset(psd_scan->ant_det_peak_val, 0, 16*sizeof(u8));
\r
3143 memset(psd_scan->ant_det_peak_freq, 0, 16*sizeof(u8));
\r
3145 if (board_info->tfbga_package) /* for TFBGA */
\r
3146 psd_scan->ant_det_thres_offset = 5;
\r
3148 psd_scan->ant_det_thres_offset = 0;
\r
3153 if (bt_le_channel == 39)
\r
3154 wlpsd_cent_freq = 2484;
\r
3156 for (i = 1; i <= 13; i++) {
\r
3157 if (bt_le_ch[i - 1] ==
\r
3159 wlpsd_cent_freq = 2412
\r
3167 BTC_SPRINTF(trace_buf,
\r
3169 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort!!, Invalid LE channel = %d\n ",
\r
3171 BTC_TRACE(trace_buf);
\r
3177 wlpsd_sweep_count = bt_tx_time * 238 /
\r
3178 100; /* bt_tx_time/0.42 */
\r
3179 wlpsd_sweep_count = wlpsd_sweep_count / 5;
\r
3181 if (wlpsd_sweep_count % 5 != 0)
\r
3182 wlpsd_sweep_count = (wlpsd_sweep_count /
\r
3185 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3186 "xxxxxxxxxxxxxxxx AntennaDetect(), BT_LETxTime=%d, BT_LECh = %d\n",
\r
3187 bt_tx_time, bt_le_channel);
\r
3188 BTC_TRACE(trace_buf);
\r
3189 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3190 "xxxxxxxxxxxxxxxx AntennaDetect(), wlpsd_cent_freq=%d, wlpsd_offset = %d, wlpsd_span = %d, wlpsd_sweep_count = %d\n",
\r
3194 wlpsd_sweep_count);
\r
3195 BTC_TRACE(trace_buf);
\r
3199 case 1: /* stop coex DM & set antenna path */
\r
3200 /* Stop Coex DM */
\r
3201 btcoexist->stop_coex_dm = true;
\r
3203 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3204 "xxxxxxxxxxxxxxxx AntennaDetect(), Stop Coex DM!!\n");
\r
3205 BTC_TRACE(trace_buf);
\r
3207 /* set native power save */
\r
3208 halbtc8723b1ant_power_save_state(btcoexist,
\r
3209 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
\r
3211 /* Set TDMA off, */
\r
3212 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC,
\r
3215 /* Set coex table */
\r
3216 halbtc8723b1ant_coex_table_with_type(btcoexist,
\r
3219 if (board_info->btdm_ant_pos ==
\r
3220 BTC_ANTENNA_AT_MAIN_PORT) {
\r
3221 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3222 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Main Port\n");
\r
3223 BTC_TRACE(trace_buf);
\r
3225 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3226 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Aux Port\n");
\r
3227 BTC_TRACE(trace_buf);
\r
3230 /* Set Antenna path, switch WiFi to un-certain antenna port */
\r
3231 halbtc8723b1ant_set_ant_path(btcoexist,
\r
3232 BTC_ANT_PATH_BT, FORCE_EXEC, false,
\r
3235 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3236 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to BT!!\n");
\r
3237 BTC_TRACE(trace_buf);
\r
3239 /* Set AFH mask on at WiFi channel 2472MHz +/- 10MHz */
\r
3240 h2c_parameter[0] = 0x1;
\r
3241 h2c_parameter[1] = 0xd;
\r
3242 h2c_parameter[2] = 0x14;
\r
3244 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3245 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
\r
3247 h2c_parameter[2]);
\r
3248 BTC_TRACE(trace_buf);
\r
3250 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
\r
3253 u32tmp = btcoexist->btc_read_4byte(btcoexist,
\r
3255 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
\r
3256 u8tmpb = btcoexist->btc_read_1byte(btcoexist,
\r
3259 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3260 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x778=0x%x\n",
\r
3261 u32tmp, u8tmpa, u8tmpb);
\r
3262 BTC_TRACE(trace_buf);
\r
3266 case 2: /* Pre-sweep background psd */
\r
3267 if (!halbtc8723b1ant_psd_sweep_point(btcoexist,
\r
3268 wlpsd_cent_freq, wlpsd_offset, wlpsd_span,
\r
3269 BT_8723B_1ANT_ANTDET_PSD_POINTS,
\r
3270 BT_8723B_1ANT_ANTDET_PSD_AVGNUM, 3)) {
\r
3271 board_info->btdm_ant_det_finish = false;
\r
3272 board_info->btdm_ant_num_by_ant_det = 1;
\r
3273 psd_scan->ant_det_result = 8;
\r
3278 psd_scan->ant_det_pre_psdscan_peak_val =
\r
3279 psd_scan->psd_max_value;
\r
3281 if (psd_scan->psd_max_value >
\r
3282 (BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
\r
3283 + psd_scan->ant_det_thres_offset) * 100) {
\r
3284 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3285 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort Antenna Detection!! becaus background = %d > thres (%d)\n",
\r
3286 psd_scan->psd_max_value / 100,
\r
3287 BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
\r
3288 + psd_scan->ant_det_thres_offset);
\r
3289 BTC_TRACE(trace_buf);
\r
3290 board_info->btdm_ant_det_finish = false;
\r
3291 board_info->btdm_ant_num_by_ant_det = 1;
\r
3292 psd_scan->ant_det_result = 5;
\r
3295 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3296 "xxxxxxxxxxxxxxxx AntennaDetect(), Start Antenna Detection!! becaus background = %d <= thres (%d)\n",
\r
3297 psd_scan->psd_max_value / 100,
\r
3298 BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
\r
3299 + psd_scan->ant_det_thres_offset);
\r
3300 BTC_TRACE(trace_buf);
\r
3305 bt_resp = btcoexist->btc_set_bt_ant_detection(
\r
3306 btcoexist, (u8)(bt_tx_time & 0xff),
\r
3307 (u8)(bt_le_channel & 0xff));
\r
3309 if (!halbtc8723b1ant_psd_sweep_point(btcoexist,
\r
3310 wlpsd_cent_freq, wlpsd_offset,
\r
3312 BT_8723B_1ANT_ANTDET_PSD_POINTS,
\r
3313 BT_8723B_1ANT_ANTDET_PSD_AVGNUM,
\r
3314 wlpsd_sweep_count)) {
\r
3315 board_info->btdm_ant_det_finish
\r
3317 board_info->btdm_ant_num_by_ant_det
\r
3319 psd_scan->ant_det_result = 8;
\r
3324 psd_scan->ant_det_psd_scan_peak_val =
\r
3325 psd_scan->psd_max_value;
\r
3326 psd_scan->ant_det_psd_scan_peak_freq =
\r
3327 psd_scan->psd_max_value_point;
\r
3332 if (psd_scan->psd_point == 0)
\r
3333 delta_freq_per_point = 0;
\r
3335 delta_freq_per_point =
\r
3336 psd_scan->psd_band_width /
\r
3337 psd_scan->psd_point;
\r
3339 psd_rep1 = psd_scan->psd_max_value / 100;
\r
3340 psd_rep2 = psd_scan->psd_max_value - psd_rep1 *
\r
3343 freq = ((psd_scan->real_cent_freq - 20) *
\r
3344 1000000 + psd_scan->psd_max_value_point
\r
3345 * delta_freq_per_point);
\r
3346 freq1 = freq / 1000000;
\r
3347 freq2 = freq / 1000 - freq1 * 1000;
\r
3349 if (freq2 < 100) {
\r
3350 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3351 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.0%d MHz",
\r
3353 BTC_TRACE(trace_buf);
\r
3354 CL_SPRINTF(psd_scan->ant_det_peak_freq,
\r
3355 BT_8723B_1ANT_ANTDET_BUF_LEN,
\r
3356 "%d.0%d", freq1, freq2);
\r
3358 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3359 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.%d MHz",
\r
3361 BTC_TRACE(trace_buf);
\r
3362 CL_SPRINTF(psd_scan->ant_det_peak_freq,
\r
3363 BT_8723B_1ANT_ANTDET_BUF_LEN,
\r
3364 "%d.%d", freq1, freq2);
\r
3367 if (psd_rep2 < 10) {
\r
3368 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3369 ", Value = %d.0%d dB\n",
\r
3370 psd_rep1, psd_rep2);
\r
3371 BTC_TRACE(trace_buf);
\r
3372 CL_SPRINTF(psd_scan->ant_det_peak_val,
\r
3373 BT_8723B_1ANT_ANTDET_BUF_LEN,
\r
3374 "%d.0%d", psd_rep1, psd_rep2);
\r
3376 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3377 ", Value = %d.%d dB\n",
\r
3378 psd_rep1, psd_rep2);
\r
3379 BTC_TRACE(trace_buf);
\r
3380 CL_SPRINTF(psd_scan->ant_det_peak_val,
\r
3381 BT_8723B_1ANT_ANTDET_BUF_LEN,
\r
3382 "%d.%d", psd_rep1, psd_rep2);
\r
3385 psd_scan->ant_det_is_btreply_available = true;
\r
3387 if (bt_resp == false) {
\r
3388 psd_scan->ant_det_is_btreply_available =
\r
3390 psd_scan->ant_det_result = 0;
\r
3391 board_info->btdm_ant_det_finish = false;
\r
3392 board_info->btdm_ant_num_by_ant_det = 1;
\r
3393 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3394 "xxxxxxxxxxxxxxxx AntennaDetect(), BT Response = Fail\n ");
\r
3395 BTC_TRACE(trace_buf);
\r
3396 } else if (psd_scan->psd_max_value >
\r
3397 (BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
\r
3399 psd_scan->ant_det_result = 1;
\r
3400 board_info->btdm_ant_det_finish = true;
\r
3401 board_info->btdm_ant_num_by_ant_det = 2;
\r
3402 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3403 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Bad-Isolation!!\n");
\r
3404 BTC_TRACE(trace_buf);
\r
3405 } else if (psd_scan->psd_max_value >
\r
3406 (BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
\r
3407 + psd_scan->ant_det_thres_offset) * 100) {
\r
3408 psd_scan->ant_det_result = 2;
\r
3409 board_info->btdm_ant_det_finish = true;
\r
3410 board_info->btdm_ant_num_by_ant_det = 2;
\r
3411 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3412 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Good-Isolation!!\n");
\r
3413 BTC_TRACE(trace_buf);
\r
3414 } else if (psd_scan->psd_max_value >
\r
3415 (BT_8723B_1ANT_ANTDET_PSDTHRES_1ANT) *
\r
3417 psd_scan->ant_det_result = 3;
\r
3418 board_info->btdm_ant_det_finish = true;
\r
3419 board_info->btdm_ant_num_by_ant_det = 1;
\r
3420 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3421 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant!!\n");
\r
3422 BTC_TRACE(trace_buf);
\r
3424 psd_scan->ant_det_result = 4;
\r
3425 board_info->btdm_ant_det_finish = false;
\r
3426 board_info->btdm_ant_num_by_ant_det = 1;
\r
3427 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3428 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant, un-certainity!!\n");
\r
3429 BTC_TRACE(trace_buf);
\r
3434 case 99: /* restore setup */
\r
3436 /* Set AFH mask off at WiFi channel 2472MHz +/- 10MHz */
\r
3437 h2c_parameter[0] = 0x0;
\r
3438 h2c_parameter[1] = 0x0;
\r
3439 h2c_parameter[2] = 0x0;
\r
3441 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3442 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
\r
3443 h2c_parameter[1], h2c_parameter[2]);
\r
3444 BTC_TRACE(trace_buf);
\r
3446 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
\r
3449 /* Set Antenna Path */
\r
3450 halbtc8723b1ant_set_ant_path(btcoexist,
\r
3451 BTC_ANT_PATH_PTA, FORCE_EXEC, false,
\r
3453 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3454 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to PTA\n!!");
\r
3455 BTC_TRACE(trace_buf);
\r
3457 /* Resume Coex DM */
\r
3458 btcoexist->stop_coex_dm = false;
\r
3459 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3460 "xxxxxxxxxxxxxxxx AntennaDetect(), Resume Coex DM\n!!");
\r
3461 BTC_TRACE(trace_buf);
\r
3463 /* stimulate coex running */
\r
3464 halbtc8723b1ant_run_coexist_mechanism(
\r
3466 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3467 "xxxxxxxxxxxxxxxx AntennaDetect(), Stimulate Coex running\n!!");
\r
3468 BTC_TRACE(trace_buf);
\r
3474 } while (!outloop);
\r
3480 void halbtc8723b1ant_psd_antenna_detection_check(IN struct btc_coexist
\r
3483 static u32 ant_det_count = 0, ant_det_fail_count = 0;
\r
3484 struct btc_board_info *board_info = &btcoexist->board_info;
\r
3486 boolean scan, roam;
\r
3488 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
\r
3489 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
\r
3492 /* psd_scan->ant_det_bt_tx_time = 20; */
\r
3493 psd_scan->ant_det_bt_tx_time =
\r
3494 BT_8723B_1ANT_ANTDET_BTTXTIME; /* 0.42ms*50 = 20ms (0.42ms = 1 PSD sweep) */
\r
3495 psd_scan->ant_det_bt_le_channel = BT_8723B_1ANT_ANTDET_BTTXCHANNEL;
\r
3499 psd_scan->ant_det_try_count = ant_det_count;
\r
3501 if (scan || roam) {
\r
3502 board_info->btdm_ant_det_finish = false;
\r
3503 psd_scan->ant_det_result = 6;
\r
3504 } else if (coex_sta->bt_disabled) {
\r
3505 board_info->btdm_ant_det_finish = false;
\r
3506 psd_scan->ant_det_result = 11;
\r
3507 } else if (coex_sta->num_of_profile >= 1) {
\r
3508 board_info->btdm_ant_det_finish = false;
\r
3509 psd_scan->ant_det_result = 7;
\r
3511 !psd_scan->ant_det_is_ant_det_available) { /* Antenna initial setup is not ready */
\r
3512 board_info->btdm_ant_det_finish = false;
\r
3513 psd_scan->ant_det_result = 9;
\r
3514 } else if (coex_sta->c2h_bt_inquiry_page) {
\r
3515 board_info->btdm_ant_det_finish = false;
\r
3516 psd_scan->ant_det_result = 10;
\r
3518 halbtc8723b1ant_psd_antenna_detection(btcoexist,
\r
3519 psd_scan->ant_det_bt_tx_time,
\r
3520 psd_scan->ant_det_bt_le_channel);
\r
3522 if (!board_info->btdm_ant_det_finish)
\r
3523 ant_det_fail_count++;
\r
3525 psd_scan->ant_det_fail_count = ant_det_fail_count;
\r
3530 /* ************************************************************
\r
3531 * work around function start with wa_halbtc8723b1ant_
\r
3532 * ************************************************************
\r
3533 * ************************************************************
\r
3534 * extern function start with ex_halbtc8723b1ant_
\r
3535 * ************************************************************ */
\r
3536 void ex_halbtc8723b1ant_power_on_setting(IN struct btc_coexist *btcoexist)
\r
3538 struct btc_board_info *board_info = &btcoexist->board_info;
\r
3544 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3545 "xxxxxxxxxxxxxxxx Execute 8723b 1-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
\r
3546 BTC_TRACE(trace_buf);
\r
3548 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3549 "Ant Det Finish = %s, Ant Det Number = %d\n",
\r
3550 (board_info->btdm_ant_det_finish ? "Yes" : "No"),
\r
3551 board_info->btdm_ant_num_by_ant_det);
\r
3552 BTC_TRACE(trace_buf);
\r
3555 btcoexist->stop_coex_dm = true;
\r
3557 btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
\r
3559 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
\r
3560 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
\r
3561 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
\r
3563 /* set GRAN_BT = 1 */
\r
3564 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
\r
3565 /* set WLAN_ACT = 0 */
\r
3566 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
\r
3569 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
\r
3570 /* Local setting bit define */
\r
3571 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
\r
3572 /* BIT1: "0" for internal switch; "1" for external switch */
\r
3573 /* BIT2: "0" for one antenna; "1" for two antenna */
\r
3574 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
\r
3575 if(btcoexist->chip_interface == BTC_INTF_USB) {
\r
3576 /* fixed at S0 for USB interface */
\r
3577 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
\r
3579 u8tmp |= 0x1; /* antenna inverse */
\r
3580 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
\r
3582 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
\r
3584 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
\r
3585 if (board_info->single_ant_path == 0) {
\r
3587 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x280);
\r
3588 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
\r
3590 } else if (board_info->single_ant_path == 1) {
\r
3592 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
\r
3593 u8tmp |= 0x1; /* antenna inverse */
\r
3594 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
\r
3598 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
\r
3601 if(btcoexist->chip_interface == BTC_INTF_PCI)
\r
3602 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
\r
3604 else if(btcoexist->chip_interface == BTC_INTF_SDIO)
\r
3605 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
\r
3610 void ex_halbtc8723b1ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
\r
3614 void ex_halbtc8723b1ant_init_hw_config(IN struct btc_coexist *btcoexist,
\r
3615 IN boolean wifi_only)
\r
3617 halbtc8723b1ant_init_hw_config(btcoexist, true, wifi_only);
\r
3618 btcoexist->stop_coex_dm = false;
\r
3621 void ex_halbtc8723b1ant_init_coex_dm(IN struct btc_coexist *btcoexist)
\r
3623 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3624 "[BTCoex], Coex Mechanism Init!!\n");
\r
3625 BTC_TRACE(trace_buf);
\r
3627 btcoexist->stop_coex_dm = false;
\r
3629 halbtc8723b1ant_init_coex_dm(btcoexist);
\r
3631 halbtc8723b1ant_query_bt_info(btcoexist);
\r
3634 void ex_halbtc8723b1ant_display_coex_info(IN struct btc_coexist *btcoexist)
\r
3636 struct btc_board_info *board_info = &btcoexist->board_info;
\r
3637 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
3638 u8 *cli_buf = btcoexist->cli_buf;
\r
3639 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case=0;
\r
3642 u32 fa_ofdm, fa_cck;
\r
3643 u32 fw_ver=0, bt_patch_ver=0;
\r
3644 static u8 pop_report_in_10s = 0;
\r
3646 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3647 "\r\n ============[BT Coexist info]============");
\r
3648 CL_PRINTF(cli_buf);
\r
3650 if(btcoexist->manual_control) {
\r
3651 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3652 "\r\n ============[Under Manual Control]============");
\r
3653 CL_PRINTF(cli_buf);
\r
3654 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3655 "\r\n ==========================================");
\r
3656 CL_PRINTF(cli_buf);
\r
3658 if(btcoexist->stop_coex_dm) {
\r
3659 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3660 "\r\n ============[Coex is STOPPED]============");
\r
3661 CL_PRINTF(cli_buf);
\r
3662 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3663 "\r\n ==========================================");
\r
3664 CL_PRINTF(cli_buf);
\r
3667 if (psd_scan->ant_det_try_count == 0) {
\r
3668 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
\r
3669 "Ant PG Num/ Mech/ Pos",
\r
3670 board_info->pg_ant_num, board_info->btdm_ant_num,
\r
3671 board_info->btdm_ant_pos);
\r
3672 CL_PRINTF(cli_buf);
\r
3674 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3675 "\r\n %-35s = %d/ %d/ %d (%d/%d/%d)",
\r
3676 "Ant PG Num/ Mech(Ant_Det)/ Pos",
\r
3677 board_info->pg_ant_num, board_info->btdm_ant_num_by_ant_det,
\r
3678 board_info->btdm_ant_pos,
\r
3679 psd_scan->ant_det_try_count, psd_scan->ant_det_fail_count,
\r
3680 psd_scan->ant_det_result);
\r
3681 CL_PRINTF(cli_buf);
\r
3683 if (board_info->btdm_ant_det_finish) {
\r
3684 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
\r
3685 "Ant Det PSD Value",
\r
3686 psd_scan->ant_det_peak_val);
\r
3687 CL_PRINTF(cli_buf);
\r
3691 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
\r
3692 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
\r
3693 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3694 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)/ %c",
\r
3695 "Version Coex/ Fw/ Patch/ Cut",
\r
3696 glcoex_ver_date_8723b_1ant, glcoex_ver_8723b_1ant, fw_ver,
\r
3697 bt_patch_ver, bt_patch_ver, coex_sta->cut_version + 65);
\r
3698 CL_PRINTF(cli_buf);
\r
3700 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
\r
3701 "Wifi channel informed to BT",
\r
3702 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
\r
3703 coex_dm->wifi_chnl_info[2]);
\r
3704 CL_PRINTF(cli_buf);
\r
3705 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s",
\r
3706 "WifibHiPri/ Ccklock/ CckEverLock",
\r
3707 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
\r
3708 (coex_sta->cck_lock ? "Yes" : "No"),
\r
3709 (coex_sta->cck_ever_lock ? "Yes" : "No"));
\r
3710 CL_PRINTF(cli_buf);
\r
3713 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
\r
3714 "============[Wifi Status]============");
\r
3715 CL_PRINTF(cli_buf);
\r
3716 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
\r
3718 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
\r
3719 "============[BT Status]============");
\r
3720 CL_PRINTF(cli_buf);
\r
3722 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
\r
3723 "BT Abnormal scan",
\r
3724 (coex_sta->bt_abnormal_scan) ? "Yes" : "No");
\r
3725 CL_PRINTF(cli_buf);
\r
3727 pop_report_in_10s++;
\r
3728 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = [%s/ %d/ %d/ %d] ",
\r
3729 "BT [status/ rssi/ retryCnt/ popCnt]",
\r
3730 ((coex_sta->bt_disabled)? ("disabled"): ((
\r
3731 coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan")
\r
3732 : ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
\r
3733 coex_dm->bt_status) ? "non-connected idle" :
\r
3734 ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
\r
3735 ? "connected-idle" : "busy")))),
\r
3736 coex_sta->bt_rssi, coex_sta->bt_retry_cnt,
\r
3737 coex_sta->pop_event_cnt);
\r
3738 CL_PRINTF(cli_buf);
\r
3740 if (pop_report_in_10s >= 5) {
\r
3741 coex_sta->pop_event_cnt = 0;
\r
3742 pop_report_in_10s = 0;
\r
3745 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3746 "\r\n %-35s = %d / %d / %d / %d / %d / %d",
\r
3747 "SCO/HID/PAN/A2DP/NameReq/WHQL",
\r
3748 bt_link_info->sco_exist, bt_link_info->hid_exist,
\r
3749 bt_link_info->pan_exist, bt_link_info->a2dp_exist,
\r
3750 coex_sta->c2h_bt_remote_name_req,
\r
3751 coex_sta->bt_whck_test);
\r
3752 CL_PRINTF(cli_buf);
\r
3754 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
\r
3756 (bt_link_info->slave_role) ? "Slave" : "Master");
\r
3757 CL_PRINTF(cli_buf);
\r
3759 bt_info_ext = coex_sta->bt_info_ext;
\r
3760 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d",
\r
3761 "A2DP Rate/Bitpool",
\r
3762 (bt_info_ext & BIT(0)) ? "BR" : "EDR", coex_sta->a2dp_bit_pool);
\r
3763 CL_PRINTF(cli_buf);
\r
3765 for (i = 0; i < BT_INFO_SRC_8723B_1ANT_MAX; i++) {
\r
3766 if (coex_sta->bt_info_c2h_cnt[i]) {
\r
3767 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3768 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)",
\r
3769 glbt_info_src_8723b_1ant[i],
\r
3770 coex_sta->bt_info_c2h[i][0],
\r
3771 coex_sta->bt_info_c2h[i][1],
\r
3772 coex_sta->bt_info_c2h[i][2],
\r
3773 coex_sta->bt_info_c2h[i][3],
\r
3774 coex_sta->bt_info_c2h[i][4],
\r
3775 coex_sta->bt_info_c2h[i][5],
\r
3776 coex_sta->bt_info_c2h[i][6],
\r
3777 coex_sta->bt_info_c2h_cnt[i]);
\r
3778 CL_PRINTF(cli_buf);
\r
3783 if(btcoexist->manual_control)
\r
3784 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
\r
3785 "============[mechanisms] (before Manual)============");
\r
3787 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
\r
3788 "============[mechanisms]============");
\r
3789 CL_PRINTF(cli_buf);
\r
3791 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
\r
3792 "SM[LowPenaltyRA]",
\r
3793 coex_dm->cur_low_penalty_ra);
\r
3794 CL_PRINTF(cli_buf);
\r
3796 ps_tdma_case = coex_dm->cur_ps_tdma;
\r
3797 if (board_info->btdm_ant_num_by_ant_det == 2) {
\r
3798 if (coex_dm->cur_ps_tdma_on)
\r
3799 ps_tdma_case = ps_tdma_case +
\r
3800 100; /* for WiFi RSSI low or BT RSSI low */
\r
3803 1; /* always translate to TDMA(off,1) for TDMA-off case */
\r
3805 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3806 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (%s,%s)",
\r
3808 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
\r
3809 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
\r
3810 coex_dm->ps_tdma_para[4], ps_tdma_case,
\r
3811 (coex_dm->cur_ps_tdma_on ? "On" : "Off"),
\r
3812 (coex_dm->auto_tdma_adjust ? "Adj" : "Fix"));
\r
3814 CL_PRINTF(cli_buf);
\r
3816 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
\r
3817 "Coex Table Type",
\r
3818 coex_sta->coex_table_type);
\r
3819 CL_PRINTF(cli_buf);
\r
3821 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
\r
3823 coex_dm->cur_ignore_wlan_act);
\r
3824 CL_PRINTF(cli_buf);
\r
3827 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x ", "Latest error condition(should be 0)",
\r
3828 coex_dm->error_condition);
\r
3829 CL_PRINTF(cli_buf);
\r
3833 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
\r
3834 "============[Hw setting]============");
\r
3835 CL_PRINTF(cli_buf);
\r
3837 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
\r
3838 "backup ARFR1/ARFR2/RL/AMaxTime",
\r
3839 coex_dm->backup_arfr_cnt1, coex_dm->backup_arfr_cnt2,
\r
3840 coex_dm->backup_retry_limit,
\r
3841 coex_dm->backup_ampdu_max_time);
\r
3842 CL_PRINTF(cli_buf);
\r
3844 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
\r
3845 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
\r
3846 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
\r
3847 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
\r
3848 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
\r
3849 "0x430/0x434/0x42a/0x456",
\r
3850 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
\r
3851 CL_PRINTF(cli_buf);
\r
3853 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
\r
3854 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
\r
3855 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x880);
\r
3856 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
\r
3857 "0x778/0x6cc/0x880[29:25]",
\r
3858 u8tmp[0], u32tmp[0], (u32tmp[1] & 0x3e000000) >> 25);
\r
3859 CL_PRINTF(cli_buf);
\r
3861 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
\r
3862 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
\r
3863 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x764);
\r
3864 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x76e);
\r
3865 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3866 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
\r
3867 "0x948/ 0x67[5] / 0x764 / 0x76e",
\r
3868 u32tmp[0], ((u8tmp[0] & 0x20) >> 5), (u32tmp[1] & 0xffff),
\r
3870 CL_PRINTF(cli_buf);
\r
3872 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
\r
3873 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
\r
3874 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
\r
3875 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
\r
3876 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
\r
3877 u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
\r
3878 CL_PRINTF(cli_buf);
\r
3880 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
\r
3881 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
\r
3882 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
\r
3883 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
\r
3884 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
\r
3885 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
\r
3886 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
\r
3887 ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
\r
3888 ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
\r
3889 CL_PRINTF(cli_buf);
\r
3891 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
\r
3892 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
\r
3893 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
\r
3894 "0x550(bcn ctrl)/0x522",
\r
3895 u32tmp[0], u8tmp[0]);
\r
3896 CL_PRINTF(cli_buf);
\r
3898 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
\r
3899 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
\r
3900 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
\r
3901 "0xc50(dig)/0x49c(null-drop)",
\r
3902 u32tmp[0] & 0xff, u8tmp[0]);
\r
3903 CL_PRINTF(cli_buf);
\r
3905 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
\r
3906 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
\r
3907 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
\r
3908 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
\r
3910 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
\r
3911 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
\r
3913 fa_ofdm = ((u32tmp[0] & 0xffff0000) >> 16) + ((u32tmp[1] & 0xffff0000)
\r
3914 >> 16) + (u32tmp[1] & 0xffff) + (u32tmp[2] & 0xffff) +
\r
3915 ((u32tmp[3] & 0xffff0000) >> 16) + (u32tmp[3] &
\r
3917 fa_cck = (u8tmp[0] << 8) + u8tmp[1];
\r
3919 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
\r
3920 "OFDM-CCA/OFDM-FA/CCK-FA",
\r
3921 u32tmp[0] & 0xffff, fa_ofdm, fa_cck);
\r
3922 CL_PRINTF(cli_buf);
\r
3925 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
\r
3926 "CRC_OK CCK/11g/11n/11n-Agg",
\r
3927 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
\r
3928 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_agg);
\r
3929 CL_PRINTF(cli_buf);
\r
3931 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
\r
3932 "CRC_Err CCK/11g/11n/11n-Agg",
\r
3933 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
\r
3934 coex_sta->crc_err_11n, coex_sta->crc_err_11n_agg);
\r
3935 CL_PRINTF(cli_buf);
\r
3937 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
\r
3938 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
\r
3939 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
\r
3940 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
\r
3941 "0x6c0/0x6c4/0x6c8(coexTable)",
\r
3942 u32tmp[0], u32tmp[1], u32tmp[2]);
\r
3943 CL_PRINTF(cli_buf);
\r
3945 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
\r
3946 "0x770(high-pri rx/tx)",
\r
3947 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
\r
3948 CL_PRINTF(cli_buf);
\r
3949 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
\r
3950 "0x774(low-pri rx/tx)",
\r
3951 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
\r
3952 CL_PRINTF(cli_buf);
\r
3953 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 1)
\r
3954 /* halbtc8723b1ant_monitor_bt_ctr(btcoexist); */
\r
3956 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
\r
3960 void ex_halbtc8723b1ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
\r
3962 if(btcoexist->manual_control || btcoexist->stop_coex_dm)
\r
3965 if (BTC_IPS_ENTER == type) {
\r
3966 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3967 "[BTCoex], IPS ENTER notify\n");
\r
3968 BTC_TRACE(trace_buf);
\r
3969 coex_sta->under_ips = true;
\r
3971 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
\r
3972 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
\r
3973 FORCE_EXEC, false, true);
\r
3974 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
\r
3975 } else if (BTC_IPS_LEAVE == type) {
\r
3976 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3977 "[BTCoex], IPS LEAVE notify\n");
\r
3978 BTC_TRACE(trace_buf);
\r
3980 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
\r
3981 halbtc8723b1ant_init_coex_dm(btcoexist);
\r
3982 halbtc8723b1ant_query_bt_info(btcoexist);
\r
3984 coex_sta->under_ips = false;
\r
3988 void ex_halbtc8723b1ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
\r
3990 if(btcoexist->manual_control || btcoexist->stop_coex_dm)
\r
3993 if (BTC_LPS_ENABLE == type) {
\r
3994 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
3995 "[BTCoex], LPS ENABLE notify\n");
\r
3996 BTC_TRACE(trace_buf);
\r
3997 coex_sta->under_lps = true;
\r
3998 } else if (BTC_LPS_DISABLE == type) {
\r
3999 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4000 "[BTCoex], LPS DISABLE notify\n");
\r
4001 BTC_TRACE(trace_buf);
\r
4002 coex_sta->under_lps = false;
\r
4006 void ex_halbtc8723b1ant_scan_notify(IN struct btc_coexist *btcoexist,
\r
4009 boolean wifi_connected=false, bt_hs_on=false;
\r
4010 u32 wifi_link_status=0;
\r
4011 u32 num_of_wifi_link=0;
\r
4012 boolean bt_ctrl_agg_buf_size=false;
\r
4013 u8 agg_buf_size=5;
\r
4015 u8 u8tmpa, u8tmpb;
\r
4018 if(btcoexist->manual_control ||
\r
4019 btcoexist->stop_coex_dm )
\r
4022 if (BTC_SCAN_START == type) {
\r
4023 coex_sta->wifi_is_high_pri_task = true;
\r
4024 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4025 "[BTCoex], SCAN START notify\n");
\r
4026 BTC_TRACE(trace_buf);
\r
4027 psd_scan->ant_det_is_ant_det_available = true;
\r
4028 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false,
\r
4029 8); /* Force antenna setup for no scan result issue */
\r
4030 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
4031 FORCE_EXEC, false, false);
\r
4032 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
\r
4033 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
\r
4034 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
\r
4037 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4038 "[BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
\r
4039 u32tmp, u8tmpa, u8tmpb);
\r
4040 BTC_TRACE(trace_buf);
\r
4042 coex_sta->wifi_is_high_pri_task = false;
\r
4043 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4044 "[BTCoex], SCAN FINISH notify\n");
\r
4045 BTC_TRACE(trace_buf);
\r
4047 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
\r
4048 &coex_sta->scan_ap_num);
\r
4051 if(coex_sta->bt_disabled)
\r
4054 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
\r
4055 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
4058 halbtc8723b1ant_query_bt_info(btcoexist);
\r
4060 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
\r
4061 &wifi_link_status);
\r
4062 num_of_wifi_link = wifi_link_status>>16;
\r
4063 if (num_of_wifi_link >= 2) {
\r
4064 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
\r
4065 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
\r
4066 bt_ctrl_agg_buf_size, agg_buf_size);
\r
4067 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
\r
4071 if (coex_sta->c2h_bt_inquiry_page) {
\r
4072 halbtc8723b1ant_action_bt_inquiry(btcoexist);
\r
4074 } else if (bt_hs_on) {
\r
4075 halbtc8723b1ant_action_hs(btcoexist);
\r
4079 if (BTC_SCAN_START == type) {
\r
4080 if (!wifi_connected) /* non-connected scan */
\r
4081 halbtc8723b1ant_action_wifi_not_connected_scan(
\r
4083 else /* wifi is connected */
\r
4084 halbtc8723b1ant_action_wifi_connected_scan(btcoexist);
\r
4085 } else if (BTC_SCAN_FINISH == type) {
\r
4086 if (!wifi_connected) /* non-connected scan */
\r
4087 halbtc8723b1ant_action_wifi_not_connected(btcoexist);
\r
4089 halbtc8723b1ant_action_wifi_connected(btcoexist);
\r
4093 void ex_halbtc8723b1ant_connect_notify(IN struct btc_coexist *btcoexist,
\r
4096 boolean wifi_connected=false, bt_hs_on=false;
\r
4097 u32 wifi_link_status=0;
\r
4098 u32 num_of_wifi_link=0;
\r
4099 boolean bt_ctrl_agg_buf_size=false;
\r
4100 u8 agg_buf_size=5;
\r
4102 if(btcoexist->manual_control ||
\r
4103 btcoexist->stop_coex_dm ||
\r
4104 coex_sta->bt_disabled )
\r
4107 if (BTC_ASSOCIATE_START == type) {
\r
4108 coex_sta->wifi_is_high_pri_task = true;
\r
4109 psd_scan->ant_det_is_ant_det_available = true;
\r
4110 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false,
\r
4111 8); /* Force antenna setup for no scan result issue */
\r
4112 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
4113 FORCE_EXEC, false, false);
\r
4114 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4115 "[BTCoex], CONNECT START notify\n");
\r
4116 BTC_TRACE(trace_buf);
\r
4117 coex_dm->arp_cnt = 0;
\r
4119 coex_sta->wifi_is_high_pri_task = false;
\r
4120 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4121 "[BTCoex], CONNECT FINISH notify\n");
\r
4122 BTC_TRACE(trace_buf);
\r
4123 /* coex_dm->arp_cnt = 0; */
\r
4126 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
\r
4127 &wifi_link_status);
\r
4128 num_of_wifi_link = wifi_link_status >> 16;
\r
4129 if (num_of_wifi_link >= 2) {
\r
4130 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
\r
4131 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
\r
4132 bt_ctrl_agg_buf_size, agg_buf_size);
\r
4133 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
\r
4137 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
\r
4138 if (coex_sta->c2h_bt_inquiry_page) {
\r
4139 halbtc8723b1ant_action_bt_inquiry(btcoexist);
\r
4141 } else if (bt_hs_on) {
\r
4142 halbtc8723b1ant_action_hs(btcoexist);
\r
4146 if (BTC_ASSOCIATE_START == type)
\r
4147 halbtc8723b1ant_action_wifi_not_connected_asso_auth(btcoexist);
\r
4148 else if (BTC_ASSOCIATE_FINISH == type) {
\r
4149 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
4151 if (!wifi_connected) /* non-connected scan */
\r
4152 halbtc8723b1ant_action_wifi_not_connected(btcoexist);
\r
4154 halbtc8723b1ant_action_wifi_connected(btcoexist);
\r
4158 void ex_halbtc8723b1ant_media_status_notify(IN struct btc_coexist *btcoexist,
\r
4161 u8 h2c_parameter[3] ={0};
\r
4163 u8 wifi_central_chnl;
\r
4164 boolean wifi_under_b_mode = false;
\r
4166 if(btcoexist->manual_control ||
\r
4167 btcoexist->stop_coex_dm ||
\r
4168 coex_sta->bt_disabled )
\r
4171 if (BTC_MEDIA_CONNECT == type) {
\r
4172 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4173 "[BTCoex], MEDIA connect notify\n");
\r
4174 BTC_TRACE(trace_buf);
\r
4175 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false,
\r
4176 8); /* Force antenna setup for no scan result issue */
\r
4177 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
\r
4178 FORCE_EXEC, false, false);
\r
4179 psd_scan->ant_det_is_ant_det_available = true;
\r
4180 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
\r
4181 &wifi_under_b_mode);
\r
4183 /* Set CCK Tx/Rx high Pri except 11b mode */
\r
4184 if (wifi_under_b_mode) {
\r
4185 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
\r
4186 0x00); /* CCK Tx */
\r
4187 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
\r
4188 0x00); /* CCK Rx */
\r
4190 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
\r
4191 0x00); /* CCK Tx */
\r
4192 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
\r
4193 0x10); /* CCK Rx */
\r
4196 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
\r
4198 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
\r
4200 coex_dm->backup_retry_limit = btcoexist->btc_read_2byte(
\r
4201 btcoexist, 0x42a);
\r
4202 coex_dm->backup_ampdu_max_time = btcoexist->btc_read_1byte(
\r
4203 btcoexist, 0x456);
\r
4205 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4206 "[BTCoex], MEDIA disconnect notify\n");
\r
4207 BTC_TRACE(trace_buf);
\r
4208 coex_dm->arp_cnt = 0;
\r
4210 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
\r
4211 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
\r
4213 coex_sta->cck_ever_lock = false;
\r
4216 /* only 2.4G we need to inform bt the chnl mask */
\r
4217 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
\r
4218 &wifi_central_chnl);
\r
4219 if ((BTC_MEDIA_CONNECT == type) &&
\r
4220 (wifi_central_chnl <= 14)) {
\r
4221 /* h2c_parameter[0] = 0x1; */
\r
4222 h2c_parameter[0] = 0x0;
\r
4223 h2c_parameter[1] = wifi_central_chnl;
\r
4224 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
\r
4225 if (BTC_WIFI_BW_HT40 == wifi_bw)
\r
4226 h2c_parameter[2] = 0x30;
\r
4228 h2c_parameter[2] = 0x20;
\r
4231 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
\r
4232 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
\r
4233 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
\r
4235 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
\r
4238 void ex_halbtc8723b1ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
\r
4241 boolean bt_hs_on=false;
\r
4242 u32 wifi_link_status=0;
\r
4243 u32 num_of_wifi_link=0;
\r
4244 boolean bt_ctrl_agg_buf_size=false, under_4way=false;
\r
4245 u8 agg_buf_size=5;
\r
4247 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
\r
4250 if(btcoexist->manual_control ||
\r
4251 btcoexist->stop_coex_dm ||
\r
4252 coex_sta->bt_disabled )
\r
4255 if (BTC_PACKET_DHCP == type ||
\r
4256 BTC_PACKET_EAPOL == type ||
\r
4257 BTC_PACKET_ARP == type) {
\r
4258 if (BTC_PACKET_ARP == type) {
\r
4259 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4260 "[BTCoex], specific Packet ARP notify\n");
\r
4261 BTC_TRACE(trace_buf);
\r
4263 coex_dm->arp_cnt++;
\r
4264 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4265 "[BTCoex], ARP Packet Count = %d\n",
\r
4266 coex_dm->arp_cnt);
\r
4267 BTC_TRACE(trace_buf);
\r
4269 if ((coex_dm->arp_cnt >= 10) &&
\r
4270 (!under_4way)) /* if APR PKT > 10 after connect, do not go to ActionWifiConnectedSpecificPacket(btcoexist) */
\r
4271 coex_sta->wifi_is_high_pri_task = false;
\r
4273 coex_sta->wifi_is_high_pri_task = true;
\r
4275 coex_sta->wifi_is_high_pri_task = true;
\r
4276 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4277 "[BTCoex], specific Packet DHCP or EAPOL notify\n");
\r
4278 BTC_TRACE(trace_buf);
\r
4281 coex_sta->wifi_is_high_pri_task = false;
\r
4282 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4283 "[BTCoex], specific Packet [Type = %d] notify\n", type);
\r
4284 BTC_TRACE(trace_buf);
\r
4287 coex_sta->specific_pkt_period_cnt = 0;
\r
4289 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
\r
4290 &wifi_link_status);
\r
4291 num_of_wifi_link = wifi_link_status >> 16;
\r
4292 if (num_of_wifi_link >= 2) {
\r
4293 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
\r
4294 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
\r
4295 bt_ctrl_agg_buf_size, agg_buf_size);
\r
4296 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
\r
4300 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
\r
4301 if (coex_sta->c2h_bt_inquiry_page) {
\r
4302 halbtc8723b1ant_action_bt_inquiry(btcoexist);
\r
4304 } else if (bt_hs_on) {
\r
4305 halbtc8723b1ant_action_hs(btcoexist);
\r
4309 if (BTC_PACKET_DHCP == type ||
\r
4310 BTC_PACKET_EAPOL == type ||
\r
4311 ((BTC_PACKET_ARP == type) && (coex_sta->wifi_is_high_pri_task)))
\r
4312 halbtc8723b1ant_action_wifi_connected_specific_packet(btcoexist);
\r
4315 void ex_halbtc8723b1ant_bt_info_notify(IN struct btc_coexist *btcoexist,
\r
4316 IN u8 *tmp_buf, IN u8 length)
\r
4319 u8 i, rsp_source=0;
\r
4320 boolean wifi_connected=false;
\r
4321 boolean bt_busy=false;
\r
4322 struct btc_board_info *board_info = &btcoexist->board_info;
\r
4324 coex_sta->c2h_bt_info_req_sent = false;
\r
4326 rsp_source = tmp_buf[0]&0xf;
\r
4327 if(rsp_source >= BT_INFO_SRC_8723B_1ANT_MAX)
\r
4328 rsp_source = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
\r
4329 coex_sta->bt_info_c2h_cnt[rsp_source]++;
\r
4331 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4332 "[BTCoex], Bt info[%d], length=%d, hex data=[", rsp_source,
\r
4334 BTC_TRACE(trace_buf);
\r
4335 for (i = 0; i < length; i++) {
\r
4336 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
\r
4338 bt_info = tmp_buf[i];
\r
4339 if (i == length - 1) {
\r
4340 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
\r
4342 BTC_TRACE(trace_buf);
\r
4344 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
\r
4346 BTC_TRACE(trace_buf);
\r
4350 /* if 0xff, it means BT is under WHCK test */
\r
4351 if (bt_info == 0xff)
\r
4352 coex_sta->bt_whck_test = true;
\r
4354 coex_sta->bt_whck_test = false;
\r
4356 if (BT_INFO_SRC_8723B_1ANT_WIFI_FW != rsp_source) {
\r
4357 coex_sta->bt_retry_cnt = /* [3:0] */
\r
4358 coex_sta->bt_info_c2h[rsp_source][2]&0xf;
\r
4360 if (coex_sta->bt_retry_cnt >= 1)
\r
4361 coex_sta->pop_event_cnt++;
\r
4363 if (coex_sta->bt_info_c2h[rsp_source][2]&0x20)
\r
4364 coex_sta->c2h_bt_remote_name_req = true;
\r
4366 coex_sta->c2h_bt_remote_name_req = false;
\r
4368 coex_sta->bt_rssi =
\r
4369 coex_sta->bt_info_c2h[rsp_source][3]*2-90;
\r
4370 /* coex_sta->bt_info_c2h[rsp_source][3]*2+10; */
\r
4372 coex_sta->bt_info_ext =
\r
4373 coex_sta->bt_info_c2h[rsp_source][4];
\r
4375 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49) {
\r
4376 coex_sta->a2dp_bit_pool =
\r
4377 coex_sta->bt_info_c2h[rsp_source][6];
\r
4379 coex_sta->a2dp_bit_pool = 0;
\r
4381 coex_sta->bt_tx_rx_mask = (coex_sta->bt_info_c2h[rsp_source][2]
\r
4383 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
\r
4384 &coex_sta->bt_tx_rx_mask);
\r
4386 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
4387 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
\r
4388 if ((board_info->btdm_ant_det_finish) &&
\r
4389 (board_info->btdm_ant_num_by_ant_det == 2)) {
\r
4390 if (coex_sta->bt_tx_rx_mask) {
\r
4391 /* BT into is responded by BT FW and BT RF REG 0x3C != 0x15 => Need to switch BT TRx Mask */
\r
4392 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4393 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x1\n");
\r
4394 BTC_TRACE(trace_buf);
\r
4396 /* BT TRx Mask un-lock 0x2c[0], 0x30[0] = 1 */
\r
4397 btcoexist->btc_set_bt_reg(btcoexist,
\r
4398 BTC_BT_REG_RF, 0x2c, 0x7c45);
\r
4399 btcoexist->btc_set_bt_reg(btcoexist,
\r
4400 BTC_BT_REG_RF, 0x30, 0x7c45);
\r
4402 btcoexist->btc_set_bt_reg(btcoexist,
\r
4403 BTC_BT_REG_RF, 0x3c, 0x1);
\r
4410 if (!coex_sta->bt_tx_rx_mask) {
\r
4411 /* BT into is responded by BT FW and BT RF REG 0x3C != 0x15 => Need to switch BT TRx Mask */
\r
4412 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4413 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
\r
4414 BTC_TRACE(trace_buf);
\r
4415 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
\r
4418 /* BT TRx Mask lock 0x2c[0], 0x30[0] = 0 */
\r
4419 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
\r
4421 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
\r
4426 /* Here we need to resend some wifi info to BT */
\r
4427 /* because bt is reset and loss of the info. */
\r
4428 if (coex_sta->bt_info_ext & BIT(1)) {
\r
4429 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4430 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
\r
4431 BTC_TRACE(trace_buf);
\r
4432 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
\r
4434 if (wifi_connected)
\r
4435 ex_halbtc8723b1ant_media_status_notify(
\r
4436 btcoexist, BTC_MEDIA_CONNECT);
\r
4438 ex_halbtc8723b1ant_media_status_notify(
\r
4439 btcoexist, BTC_MEDIA_DISCONNECT);
\r
4442 if (coex_sta->bt_info_ext & BIT(3)) {
\r
4443 if(!btcoexist->manual_control &&
\r
4444 !btcoexist->stop_coex_dm) {
\r
4445 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4446 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
\r
4447 BTC_TRACE(trace_buf);
\r
4448 halbtc8723b1ant_ignore_wlan_act(btcoexist,
\r
4449 FORCE_EXEC, false);
\r
4452 /* BT already NOT ignore Wlan active, do nothing here. */
\r
4454 #if(BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
\r
4455 if ((coex_sta->bt_info_ext & BIT(4))) {
\r
4456 /* BT auto report already enabled, do nothing */
\r
4458 halbtc8723b1ant_bt_auto_report(btcoexist, FORCE_EXEC,
\r
4463 /* check BIT2 first ==> check if bt is under inquiry or page scan */
\r
4464 if (bt_info & BT_INFO_8723B_1ANT_B_INQ_PAGE)
\r
4465 coex_sta->c2h_bt_inquiry_page = true;
\r
4467 coex_sta->c2h_bt_inquiry_page = false;
\r
4469 coex_sta->num_of_profile = 0;
\r
4471 /* set link exist status */
\r
4472 if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) {
\r
4473 coex_sta->bt_link_exist = false;
\r
4474 coex_sta->pan_exist = false;
\r
4475 coex_sta->a2dp_exist = false;
\r
4476 coex_sta->hid_exist = false;
\r
4477 coex_sta->sco_exist = false;
\r
4479 coex_sta->bt_hi_pri_link_exist = false;
\r
4480 } else { /* connection exists */
\r
4481 coex_sta->bt_link_exist = true;
\r
4482 if (bt_info & BT_INFO_8723B_1ANT_B_FTP) {
\r
4483 coex_sta->pan_exist = true;
\r
4484 coex_sta->num_of_profile++;
\r
4486 coex_sta->pan_exist = false;
\r
4487 if (bt_info & BT_INFO_8723B_1ANT_B_A2DP) {
\r
4488 coex_sta->a2dp_exist = true;
\r
4489 coex_sta->num_of_profile++;
\r
4491 coex_sta->a2dp_exist = false;
\r
4492 if (bt_info & BT_INFO_8723B_1ANT_B_HID) {
\r
4493 coex_sta->hid_exist = true;
\r
4494 coex_sta->num_of_profile++;
\r
4496 coex_sta->hid_exist = false;
\r
4497 if (bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) {
\r
4498 coex_sta->sco_exist = true;
\r
4499 coex_sta->num_of_profile++;
\r
4501 coex_sta->sco_exist = false;
\r
4503 if ((coex_sta->hid_exist == false) &&
\r
4504 (coex_sta->c2h_bt_inquiry_page == false) &&
\r
4505 (coex_sta->sco_exist == false)) {
\r
4506 if (coex_sta->high_priority_tx +
\r
4507 coex_sta->high_priority_rx >= 160) {
\r
4508 coex_sta->hid_exist = true;
\r
4509 coex_sta->wrong_profile_notification++;
\r
4510 coex_sta->num_of_profile++;
\r
4511 bt_info = bt_info | 0x28;
\r
4515 /* Add Hi-Pri Tx/Rx counter to avoid false detection */
\r
4516 if (((coex_sta->hid_exist) || (coex_sta->sco_exist)) &&
\r
4517 (coex_sta->high_priority_tx +
\r
4518 coex_sta->high_priority_rx >= 160)
\r
4519 && (!coex_sta->c2h_bt_inquiry_page))
\r
4520 coex_sta->bt_hi_pri_link_exist = true;
\r
4522 if ((bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) &&
\r
4523 (coex_sta->num_of_profile == 0)) {
\r
4524 if (coex_sta->low_priority_tx +
\r
4525 coex_sta->low_priority_rx >= 160) {
\r
4526 coex_sta->pan_exist = true;
\r
4527 coex_sta->num_of_profile++;
\r
4528 coex_sta->wrong_profile_notification++;
\r
4529 bt_info = bt_info | 0x88;
\r
4534 halbtc8723b1ant_update_bt_link_info(btcoexist);
\r
4536 bt_info = bt_info &
\r
4537 0x1f; /* mask profile bit for connect-ilde identification ( for CSR case: A2DP idle --> 0x41) */
\r
4539 if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION))
\r
4540 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
\r
4541 else if (bt_info ==
\r
4542 BT_INFO_8723B_1ANT_B_CONNECTION) /* connection exists but no busy */
\r
4543 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
\r
4544 else if ((bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
\r
4545 (bt_info & BT_INFO_8723B_1ANT_B_SCO_BUSY))
\r
4546 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
\r
4547 else if (bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
\r
4548 if(BT_8723B_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
\r
4549 coex_dm->auto_tdma_adjust = false;
\r
4550 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
\r
4552 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_MAX;
\r
4554 if( (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
\r
4555 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
\r
4556 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) )
\r
4560 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
\r
4562 halbtc8723b1ant_run_coexist_mechanism(btcoexist);
\r
4565 void ex_halbtc8723b1ant_rf_status_notify(IN struct btc_coexist *btcoexist,
\r
4569 u8 u8tmpa,u8tmpb, u8tmpc;
\r
4571 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
\r
4572 BTC_TRACE(trace_buf);
\r
4574 if (BTC_RF_ON == type) {
\r
4575 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4576 "[BTCoex], RF is turned ON!!\n");
\r
4577 BTC_TRACE(trace_buf);
\r
4578 btcoexist->stop_coex_dm = false;
\r
4579 } else if (BTC_RF_OFF == type) {
\r
4580 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4581 "[BTCoex], RF is turned OFF!!\n");
\r
4582 BTC_TRACE(trace_buf);
\r
4584 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
4586 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
\r
4587 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
\r
4588 FORCE_EXEC, false, true);
\r
4590 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
\r
4591 btcoexist->stop_coex_dm = true;
\r
4593 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
\r
4594 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
\r
4595 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
\r
4596 u8tmpc = btcoexist->btc_read_1byte(btcoexist, 0x76e);
\r
4599 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4600 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x, 0x76e=0x%x\n",
\r
4601 u32tmp, u8tmpa, u8tmpb, u8tmpc);
\r
4602 BTC_TRACE(trace_buf);
\r
4607 void ex_halbtc8723b1ant_halt_notify(IN struct btc_coexist *btcoexist)
\r
4609 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
\r
4610 BTC_TRACE(trace_buf);
\r
4612 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
\r
4614 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
\r
4615 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, FORCE_EXEC,
\r
4618 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
\r
4620 ex_halbtc8723b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
\r
4622 btcoexist->stop_coex_dm = true;
\r
4625 void ex_halbtc8723b1ant_pnp_notify(IN struct btc_coexist *btcoexist,
\r
4628 if (BTC_WIFI_PNP_SLEEP == pnp_state) {
\r
4629 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4630 "[BTCoex], Pnp notify to SLEEP\n");
\r
4631 BTC_TRACE(trace_buf);
\r
4633 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
\r
4635 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
\r
4636 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
\r
4637 FORCE_EXEC, false, true);
\r
4638 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
\r
4640 /* Sinda 20150819, workaround for driver skip leave IPS/LPS to speed up sleep time. */
\r
4641 /* Driver do not leave IPS/LPS when driver is going to sleep, so BTCoexistence think wifi is still under IPS/LPS */
\r
4642 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch state after wakeup. */
\r
4643 coex_sta->under_ips = false;
\r
4644 coex_sta->under_lps = false;
\r
4645 btcoexist->stop_coex_dm = true;
\r
4646 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
\r
4647 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4648 "[BTCoex], Pnp notify to WAKE UP\n");
\r
4649 BTC_TRACE(trace_buf);
\r
4650 btcoexist->stop_coex_dm = false;
\r
4651 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
\r
4652 halbtc8723b1ant_init_coex_dm(btcoexist);
\r
4653 halbtc8723b1ant_query_bt_info(btcoexist);
\r
4657 void ex_halbtc8723b1ant_coex_dm_reset(IN struct btc_coexist *btcoexist)
\r
4660 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
\r
4661 /* btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
\r
4662 /* btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x2, 0xfffff, 0x0); */
\r
4663 halbtc8723b1ant_init_coex_dm(btcoexist);
\r
4666 void ex_halbtc8723b1ant_periodical(IN struct btc_coexist *btcoexist)
\r
4668 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
\r
4670 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4671 "[BTCoex], ==========================Periodical===========================\n");
\r
4672 BTC_TRACE(trace_buf);
\r
4674 #if(BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
\r
4675 halbtc8723b1ant_query_bt_info(btcoexist);
\r
4676 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist);
\r
4678 halbtc8723b1ant_monitor_bt_ctr(btcoexist);
\r
4679 halbtc8723b1ant_monitor_wifi_ctr(btcoexist);
\r
4680 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
4681 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist);
\r
4684 if ((coex_sta->high_priority_tx + coex_sta->high_priority_rx < 50) &&
\r
4685 (bt_link_info->hid_exist == true))
\r
4686 bt_link_info->hid_exist = false;
\r
4688 if( halbtc8723b1ant_is_wifi_status_changed(btcoexist) ||
\r
4689 coex_dm->auto_tdma_adjust )
\r
4690 halbtc8723b1ant_run_coexist_mechanism(btcoexist);
\r
4692 coex_sta->specific_pkt_period_cnt++;
\r
4694 /* sample to set bt to execute Ant detection */
\r
4695 /* btcoexist->btc_set_bt_ant_detection(btcoexist, 20, 14);
\r
4697 if (psd_scan->is_ant_det_enable)
\r
4699 if (psd_scan->psd_gen_count > psd_scan->realseconds)
\r
4700 psd_scan->psd_gen_count = 0;
\r
4702 halbtc8723b1ant_antenna_detection(btcoexist, psd_scan->realcent_freq, psd_scan->realoffset, psd_scan->realspan, psd_scan->realseconds);
\r
4703 psd_scan->psd_gen_total_count +=2;
\r
4704 psd_scan->psd_gen_count += 2;
\r
4710 void ex_halbtc8723b1ant_antenna_detection(IN struct btc_coexist *btcoexist,
\r
4711 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
\r
4713 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
4714 static u32 ant_det_count = 0, ant_det_fail_count = 0;
\r
4715 struct btc_board_info *board_info = &btcoexist->board_info;
\r
4716 /*boolean scan, roam;*/
\r
4718 if (seconds == 0) {
\r
4719 psd_scan->ant_det_try_count = 0;
\r
4720 psd_scan->ant_det_fail_count = 0;
\r
4721 ant_det_count = 0;
\r
4722 ant_det_fail_count = 0;
\r
4723 board_info->btdm_ant_det_finish = false;
\r
4724 board_info->btdm_ant_num_by_ant_det = 1;
\r
4728 if (!board_info->btdm_ant_det_finish) {
\r
4729 psd_scan->ant_det_inteval_count =
\r
4730 psd_scan->ant_det_inteval_count + 2;
\r
4732 if (psd_scan->ant_det_inteval_count >=
\r
4733 BT_8723B_1ANT_ANTDET_RETRY_INTERVAL) {
\r
4734 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4735 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is up, Try Detect!!\n");
\r
4736 BTC_TRACE(trace_buf);
\r
4737 halbtc8723b1ant_psd_antenna_detection_check(btcoexist);
\r
4739 if (board_info->btdm_ant_det_finish) {
\r
4740 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4741 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Success!!\n");
\r
4742 BTC_TRACE(trace_buf);
\r
4744 if (board_info->btdm_ant_num_by_ant_det == 2)
\r
4745 halbtc8723b1ant_mechanism_switch(
\r
4748 halbtc8723b1ant_mechanism_switch(
\r
4749 btcoexist, false);
\r
4752 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4753 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Fail!!\n");
\r
4754 BTC_TRACE(trace_buf);
\r
4756 psd_scan->ant_det_inteval_count = 0;
\r
4758 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
\r
4759 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is not up! (%d)\n",
\r
4760 psd_scan->ant_det_inteval_count);
\r
4761 BTC_TRACE(trace_buf);
\r
4769 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
\r
4770 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
\r
4773 psd_scan->ant_det_bt_tx_time = seconds;
\r
4774 psd_scan->ant_det_bt_le_channel = cent_freq;
\r
4778 psd_scan->ant_det_try_count = 0;
\r
4779 psd_scan->ant_det_fail_count = 0;
\r
4780 ant_det_count = 0;
\r
4781 ant_det_fail_count = 0;
\r
4782 board_info->btdm_ant_det_finish = false;
\r
4783 board_info->btdm_ant_num_by_ant_det = 1;
\r
4790 psd_scan->ant_det_try_count = ant_det_count;
\r
4794 board_info->btdm_ant_det_finish = false;
\r
4795 psd_scan->ant_det_result = 6;
\r
4797 else if (coex_sta->num_of_profile >= 1)
\r
4799 board_info->btdm_ant_det_finish = false;
\r
4800 psd_scan->ant_det_result = 7;
\r
4802 else if (!psd_scan->ant_det_is_ant_det_available)
\r
4804 board_info->btdm_ant_det_finish = false;
\r
4805 psd_scan->ant_det_result = 9;
\r
4807 else if (coex_sta->c2h_bt_inquiry_page)
\r
4809 board_info->btdm_ant_det_finish = false;
\r
4810 psd_scan->ant_det_result = 10;
\r
4817 if (!board_info->btdm_ant_det_finish)
\r
4818 ant_det_fail_count++;
\r
4820 psd_scan->ant_det_fail_count = ant_det_fail_count;
\r
4826 void ex_halbtc8723b1ant_display_ant_detection(IN struct btc_coexist *btcoexist)
\r
4828 #if BT_8723B_1ANT_ANTDET_ENABLE
\r
4829 struct btc_board_info *board_info = &btcoexist->board_info;
\r
4831 if (psd_scan->ant_det_try_count != 0) {
\r
4832 halbtc8723b1ant_psd_show_antenna_detect_result(btcoexist);
\r
4834 if (board_info->btdm_ant_det_finish)
\r
4835 halbtc8723b1ant_psd_showdata(btcoexist);
\r
4840 /* halbtc8723b1ant_show_psd_data(btcoexist); */
\r
4845 #endif /* #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1) */
\r
projects / firefly-linux-kernel-4.4.55.git / blob