1 /* ************************************************************
4 * This file is for RTL8723B Co-exist mechanism
7 * 2012/11/15 Cosa first check in.
9 * ************************************************************ */
11 /* ************************************************************
13 * ************************************************************ */
14 #include "mp_precomp.h"
16 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
18 #if (RTL8723B_SUPPORT == 1)
19 /* ************************************************************
20 * Global variables, these are static variables
21 * ************************************************************ */
22 static u8 *trace_buf = &gl_btc_trace_buf[0];
23 static struct coex_dm_8723b_2ant glcoex_dm_8723b_2ant;
24 static struct coex_dm_8723b_2ant *coex_dm = &glcoex_dm_8723b_2ant;
25 static struct coex_sta_8723b_2ant glcoex_sta_8723b_2ant;
26 static struct coex_sta_8723b_2ant *coex_sta = &glcoex_sta_8723b_2ant;
28 const char *const glbt_info_src_8723b_2ant[] = {
31 "BT Info[bt auto report]",
34 u32 glcoex_ver_date_8723b_2ant = 20161007;
35 u32 glcoex_ver_8723b_2ant = 0x4c;
36 u32 glcoex_ver_btdesired_8723b_2ant = 0x4c;
38 /* ************************************************************
39 * local function proto type if needed
40 * ************************************************************
41 * ************************************************************
42 * local function start with halbtc8723b2ant_
43 * ************************************************************ */
44 u8 halbtc8723b2ant_bt_rssi_state(u8 *ppre_bt_rssi_state, u8 level_num,
45 u8 rssi_thresh, u8 rssi_thresh1)
48 u8 bt_rssi_state = *ppre_bt_rssi_state;
50 bt_rssi = coex_sta->bt_rssi;
53 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
54 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
55 if (bt_rssi >= (rssi_thresh +
56 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT))
57 bt_rssi_state = BTC_RSSI_STATE_HIGH;
59 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
61 if (bt_rssi < rssi_thresh)
62 bt_rssi_state = BTC_RSSI_STATE_LOW;
64 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
66 } else if (level_num == 3) {
67 if (rssi_thresh > rssi_thresh1) {
68 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
69 "[BTCoex], BT Rssi thresh error!!\n");
71 return *ppre_bt_rssi_state;
74 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
75 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
76 if (bt_rssi >= (rssi_thresh +
77 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT))
78 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
80 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
81 } else if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
82 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
83 if (bt_rssi >= (rssi_thresh1 +
84 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT))
85 bt_rssi_state = BTC_RSSI_STATE_HIGH;
86 else if (bt_rssi < rssi_thresh)
87 bt_rssi_state = BTC_RSSI_STATE_LOW;
89 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
91 if (bt_rssi < rssi_thresh1)
92 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
94 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
98 *ppre_bt_rssi_state = bt_rssi_state;
100 return bt_rssi_state;
103 u8 halbtc8723b2ant_wifi_rssi_state(IN struct btc_coexist *btcoexist,
104 IN u8 *pprewifi_rssi_state, IN u8 level_num, IN u8 rssi_thresh,
108 u8 wifi_rssi_state = *pprewifi_rssi_state;
110 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
112 if (level_num == 2) {
113 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
114 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
115 if (wifi_rssi >= (rssi_thresh +
116 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT))
117 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
119 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
121 if (wifi_rssi < rssi_thresh)
122 wifi_rssi_state = BTC_RSSI_STATE_LOW;
124 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
126 } else if (level_num == 3) {
127 if (rssi_thresh > rssi_thresh1) {
128 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
129 "[BTCoex], wifi RSSI thresh error!!\n");
130 BTC_TRACE(trace_buf);
131 return *pprewifi_rssi_state;
134 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
135 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
136 if (wifi_rssi >= (rssi_thresh +
137 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT))
138 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
140 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
141 } else if ((*pprewifi_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
142 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
143 if (wifi_rssi >= (rssi_thresh1 +
144 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT))
145 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
146 else if (wifi_rssi < rssi_thresh)
147 wifi_rssi_state = BTC_RSSI_STATE_LOW;
149 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
151 if (wifi_rssi < rssi_thresh1)
152 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
154 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
158 *pprewifi_rssi_state = wifi_rssi_state;
160 return wifi_rssi_state;
163 void halbtc8723b2ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
165 static u32 bt_disable_cnt = 0;
166 boolean bt_active = true, bt_disabled = false;
168 /* This function check if bt is disabled */
170 if (coex_sta->high_priority_tx == 0 &&
171 coex_sta->high_priority_rx == 0 &&
172 coex_sta->low_priority_tx == 0 &&
173 coex_sta->low_priority_rx == 0)
175 if (coex_sta->high_priority_tx == 0xffff &&
176 coex_sta->high_priority_rx == 0xffff &&
177 coex_sta->low_priority_tx == 0xffff &&
178 coex_sta->low_priority_rx == 0xffff)
185 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
186 "[BTCoex], bt all counters=0, %d times!!\n",
188 BTC_TRACE(trace_buf);
189 if (bt_disable_cnt >= 10)
192 if (coex_sta->bt_disabled != bt_disabled) {
193 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
194 "[BTCoex], BT is from %s to %s!!\n",
195 (coex_sta->bt_disabled ? "disabled" : "enabled"),
196 (bt_disabled ? "disabled" : "enabled"));
197 BTC_TRACE(trace_buf);
199 coex_sta->bt_disabled = bt_disabled;
200 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
203 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
205 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
212 void halbtc8723b2ant_limited_rx(IN struct btc_coexist *btcoexist,
213 IN boolean force_exec, IN boolean rej_ap_agg_pkt,
214 IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
216 boolean reject_rx_agg = rej_ap_agg_pkt;
217 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
218 u8 rx_agg_size = agg_buf_size;
220 /* ============================================ */
221 /* Rx Aggregation related setting */
222 /* ============================================ */
223 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
225 /* decide BT control aggregation buf size or not */
226 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
227 &bt_ctrl_rx_agg_size);
228 /* aggregation buf size, only work when BT control Rx aggregation size. */
229 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
230 /* real update aggregation setting */
231 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
234 void halbtc8723b2ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
236 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
237 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
239 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
244 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
245 reg_hp_tx = u32tmp & MASKLWORD;
246 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
248 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
249 reg_lp_tx = u32tmp & MASKLWORD;
250 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
252 coex_sta->high_priority_tx = reg_hp_tx;
253 coex_sta->high_priority_rx = reg_hp_rx;
254 coex_sta->low_priority_tx = reg_lp_tx;
255 coex_sta->low_priority_rx = reg_lp_rx;
257 if ((coex_sta->low_priority_tx > 1050) &&
258 (!coex_sta->c2h_bt_inquiry_page))
259 coex_sta->pop_event_cnt++;
261 if ((coex_sta->low_priority_rx >= 950) &&
262 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
263 (!coex_sta->under_ips))
264 bt_link_info->slave_role = true;
266 bt_link_info->slave_role = false;
268 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
269 "[BTCoex], High Priority Tx/Rx (reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
270 reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
271 BTC_TRACE(trace_buf);
272 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
273 "[BTCoex], Low Priority Tx/Rx (reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
274 reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
275 BTC_TRACE(trace_buf);
278 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
281 void halbtc8723b2ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
285 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_PHY_counter(
287 PHYDM_INFO_CRC32_OK_CCK);
288 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_PHY_counter(
290 PHYDM_INFO_CRC32_OK_LEGACY);
291 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_PHY_counter(
293 PHYDM_INFO_CRC32_OK_HT);
294 coex_sta->crc_ok_11n_vht =
295 btcoexist->btc_phydm_query_PHY_counter(
297 PHYDM_INFO_CRC32_OK_VHT);
299 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_PHY_counter(
301 PHYDM_INFO_CRC32_ERROR_CCK);
302 coex_sta->crc_err_11g = btcoexist->btc_phydm_query_PHY_counter(
304 PHYDM_INFO_CRC32_ERROR_LEGACY);
305 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_PHY_counter(
307 PHYDM_INFO_CRC32_ERROR_HT);
308 coex_sta->crc_err_11n_vht =
309 btcoexist->btc_phydm_query_PHY_counter(
311 PHYDM_INFO_CRC32_ERROR_VHT);
316 void halbtc8723b2ant_query_bt_info(IN struct btc_coexist *btcoexist)
318 u8 h2c_parameter[1] = {0};
320 coex_sta->c2h_bt_info_req_sent = true;
322 h2c_parameter[0] |= BIT(0); /* trigger */
324 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
327 boolean halbtc8723b2ant_is_wifi_status_changed(IN struct btc_coexist *btcoexist)
329 static boolean pre_wifi_busy = false, pre_under_4way = false,
330 pre_bt_hs_on = false;
331 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
332 boolean wifi_busy = false, under_4way = false, bt_hs_on = false;
333 boolean wifi_connected = false;
334 u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
337 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
339 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
340 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
341 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
344 if (wifi_connected) {
345 if (wifi_busy != pre_wifi_busy) {
346 pre_wifi_busy = wifi_busy;
349 if (under_4way != pre_under_4way) {
350 pre_under_4way = under_4way;
353 if (bt_hs_on != pre_bt_hs_on) {
354 pre_bt_hs_on = bt_hs_on;
359 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
360 &prewifi_rssi_state, 2,
361 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
362 coex_dm->switch_thres_offset, 0);
364 if ((BTC_RSSI_STATE_HIGH == wifi_rssi_state) ||
365 (BTC_RSSI_STATE_LOW == wifi_rssi_state))
373 void halbtc8723b2ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
375 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
376 boolean bt_hs_on = false;
378 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
380 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
381 bt_link_info->sco_exist = coex_sta->sco_exist;
382 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
383 bt_link_info->pan_exist = coex_sta->pan_exist;
384 bt_link_info->hid_exist = coex_sta->hid_exist;
386 /* work around for HS mode. */
388 bt_link_info->pan_exist = true;
389 bt_link_info->bt_link_exist = true;
392 /* check if Sco only */
393 if (bt_link_info->sco_exist &&
394 !bt_link_info->a2dp_exist &&
395 !bt_link_info->pan_exist &&
396 !bt_link_info->hid_exist)
397 bt_link_info->sco_only = true;
399 bt_link_info->sco_only = false;
401 /* check if A2dp only */
402 if (!bt_link_info->sco_exist &&
403 bt_link_info->a2dp_exist &&
404 !bt_link_info->pan_exist &&
405 !bt_link_info->hid_exist)
406 bt_link_info->a2dp_only = true;
408 bt_link_info->a2dp_only = false;
410 /* check if Pan only */
411 if (!bt_link_info->sco_exist &&
412 !bt_link_info->a2dp_exist &&
413 bt_link_info->pan_exist &&
414 !bt_link_info->hid_exist)
415 bt_link_info->pan_only = true;
417 bt_link_info->pan_only = false;
419 /* check if Hid only */
420 if (!bt_link_info->sco_exist &&
421 !bt_link_info->a2dp_exist &&
422 !bt_link_info->pan_exist &&
423 bt_link_info->hid_exist)
424 bt_link_info->hid_only = true;
426 bt_link_info->hid_only = false;
429 u8 halbtc8723b2ant_action_algorithm(IN struct btc_coexist *btcoexist)
431 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
432 boolean bt_hs_on = false;
433 u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
434 u8 num_of_diff_profile = 0;
436 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
438 if (!bt_link_info->bt_link_exist) {
439 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
440 "[BTCoex], No BT link exists!!!\n");
441 BTC_TRACE(trace_buf);
445 if (bt_link_info->sco_exist)
446 num_of_diff_profile++;
447 if (bt_link_info->hid_exist)
448 num_of_diff_profile++;
449 if (bt_link_info->pan_exist)
450 num_of_diff_profile++;
451 if (bt_link_info->a2dp_exist)
452 num_of_diff_profile++;
454 if (num_of_diff_profile == 1) {
455 if (bt_link_info->sco_exist) {
456 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
457 "[BTCoex], SCO only\n");
458 BTC_TRACE(trace_buf);
459 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
461 if (bt_link_info->hid_exist) {
462 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
463 "[BTCoex], HID only\n");
464 BTC_TRACE(trace_buf);
465 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
466 } else if (bt_link_info->a2dp_exist) {
467 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
468 "[BTCoex], A2DP only\n");
469 BTC_TRACE(trace_buf);
470 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
471 } else if (bt_link_info->pan_exist) {
473 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
474 "[BTCoex], PAN(HS) only\n");
475 BTC_TRACE(trace_buf);
477 BT_8723B_2ANT_COEX_ALGO_PANHS;
479 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
480 "[BTCoex], PAN(EDR) only\n");
481 BTC_TRACE(trace_buf);
483 BT_8723B_2ANT_COEX_ALGO_PANEDR;
487 } else if (num_of_diff_profile == 2) {
488 if (bt_link_info->sco_exist) {
489 if (bt_link_info->hid_exist) {
490 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
491 "[BTCoex], SCO + HID\n");
492 BTC_TRACE(trace_buf);
493 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
494 } else if (bt_link_info->a2dp_exist) {
495 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
496 "[BTCoex], SCO + A2DP ==> SCO\n");
497 BTC_TRACE(trace_buf);
498 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
499 } else if (bt_link_info->pan_exist) {
501 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
502 "[BTCoex], SCO + PAN(HS)\n");
503 BTC_TRACE(trace_buf);
504 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
506 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
507 "[BTCoex], SCO + PAN(EDR)\n");
508 BTC_TRACE(trace_buf);
510 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
514 if (bt_link_info->hid_exist &&
515 bt_link_info->a2dp_exist) {
517 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
518 "[BTCoex], HID + A2DP\n");
519 BTC_TRACE(trace_buf);
521 BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
523 } else if (bt_link_info->hid_exist &&
524 bt_link_info->pan_exist) {
526 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
527 "[BTCoex], HID + PAN(HS)\n");
528 BTC_TRACE(trace_buf);
529 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
531 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
532 "[BTCoex], HID + PAN(EDR)\n");
533 BTC_TRACE(trace_buf);
535 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
537 } else if (bt_link_info->pan_exist &&
538 bt_link_info->a2dp_exist) {
540 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
541 "[BTCoex], A2DP + PAN(HS)\n");
542 BTC_TRACE(trace_buf);
544 BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
546 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
547 "[BTCoex], A2DP + PAN(EDR)\n");
548 BTC_TRACE(trace_buf);
550 BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
554 } else if (num_of_diff_profile == 3) {
555 if (bt_link_info->sco_exist) {
556 if (bt_link_info->hid_exist &&
557 bt_link_info->a2dp_exist) {
558 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
559 "[BTCoex], SCO + HID + A2DP ==> HID\n");
560 BTC_TRACE(trace_buf);
561 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
562 } else if (bt_link_info->hid_exist &&
563 bt_link_info->pan_exist) {
565 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
566 "[BTCoex], SCO + HID + PAN(HS)\n");
567 BTC_TRACE(trace_buf);
569 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
571 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
572 "[BTCoex], SCO + HID + PAN(EDR)\n");
573 BTC_TRACE(trace_buf);
575 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
577 } else if (bt_link_info->pan_exist &&
578 bt_link_info->a2dp_exist) {
580 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
581 "[BTCoex], SCO + A2DP + PAN(HS)\n");
582 BTC_TRACE(trace_buf);
584 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
586 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
587 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
588 BTC_TRACE(trace_buf);
590 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
594 if (bt_link_info->hid_exist &&
595 bt_link_info->pan_exist &&
596 bt_link_info->a2dp_exist) {
598 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
599 "[BTCoex], HID + A2DP + PAN(HS)\n");
600 BTC_TRACE(trace_buf);
602 BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
604 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
605 "[BTCoex], HID + A2DP + PAN(EDR)\n");
606 BTC_TRACE(trace_buf);
608 BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
612 } else if (num_of_diff_profile >= 3) {
613 if (bt_link_info->sco_exist) {
614 if (bt_link_info->hid_exist &&
615 bt_link_info->pan_exist &&
616 bt_link_info->a2dp_exist) {
618 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
619 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
620 BTC_TRACE(trace_buf);
623 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
624 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
625 BTC_TRACE(trace_buf);
627 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
636 void halbtc8723b2ant_set_fw_dac_swing_level(IN struct btc_coexist *btcoexist,
639 u8 h2c_parameter[1] = {0};
641 /* There are several type of dacswing */
642 /* 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
643 h2c_parameter[0] = dac_swing_lvl;
645 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
648 void halbtc8723b2ant_set_fw_dec_bt_pwr(IN struct btc_coexist *btcoexist,
649 IN u8 dec_bt_pwr_lvl)
651 u8 h2c_parameter[1] = {0};
653 h2c_parameter[0] = dec_bt_pwr_lvl;
655 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
658 void halbtc8723b2ant_dec_bt_pwr(IN struct btc_coexist *btcoexist,
659 IN boolean force_exec, IN u8 dec_bt_pwr_lvl)
661 coex_dm->cur_bt_dec_pwr_lvl = dec_bt_pwr_lvl;
664 if (coex_dm->pre_bt_dec_pwr_lvl == coex_dm->cur_bt_dec_pwr_lvl)
667 halbtc8723b2ant_set_fw_dec_bt_pwr(btcoexist,
668 coex_dm->cur_bt_dec_pwr_lvl);
670 coex_dm->pre_bt_dec_pwr_lvl = coex_dm->cur_bt_dec_pwr_lvl;
673 void halbtc8723b2ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
674 IN boolean enable_auto_report)
676 u8 h2c_parameter[1] = {0};
678 h2c_parameter[0] = 0;
680 if (enable_auto_report)
681 h2c_parameter[0] |= BIT(0);
683 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
686 void halbtc8723b2ant_bt_auto_report(IN struct btc_coexist *btcoexist,
687 IN boolean force_exec, IN boolean enable_auto_report)
689 coex_dm->cur_bt_auto_report = enable_auto_report;
692 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
695 halbtc8723b2ant_set_bt_auto_report(btcoexist,
696 coex_dm->cur_bt_auto_report);
698 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
701 void halbtc8723b2ant_fw_dac_swing_lvl(IN struct btc_coexist *btcoexist,
702 IN boolean force_exec, IN u8 fw_dac_swing_lvl)
704 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
707 if (coex_dm->pre_fw_dac_swing_lvl ==
708 coex_dm->cur_fw_dac_swing_lvl)
712 halbtc8723b2ant_set_fw_dac_swing_level(btcoexist,
713 coex_dm->cur_fw_dac_swing_lvl);
715 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
718 void halbtc8723b2ant_set_sw_rf_rx_lpf_corner(IN struct btc_coexist *btcoexist,
719 IN boolean rx_rf_shrink_on)
721 if (rx_rf_shrink_on) {
722 /* Shrink RF Rx LPF corner */
723 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
724 "[BTCoex], Shrink RF Rx LPF corner!!\n");
725 BTC_TRACE(trace_buf);
726 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff,
729 /* Resume RF Rx LPF corner */
730 /* After initialized, we can use coex_dm->bt_rf_0x1e_backup */
731 if (btcoexist->initilized) {
732 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
733 "[BTCoex], Resume RF Rx LPF corner!!\n");
734 BTC_TRACE(trace_buf);
735 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
736 0xfffff, coex_dm->bt_rf_0x1e_backup);
741 void halbtc8723b2ant_rf_shrink(IN struct btc_coexist *btcoexist,
742 IN boolean force_exec, IN boolean rx_rf_shrink_on)
744 coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
747 if (coex_dm->pre_rf_rx_lpf_shrink ==
748 coex_dm->cur_rf_rx_lpf_shrink)
751 halbtc8723b2ant_set_sw_rf_rx_lpf_corner(btcoexist,
752 coex_dm->cur_rf_rx_lpf_shrink);
754 coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink;
757 void halbtc8723b2ant_set_sw_penalty_tx_rate_adaptive(IN struct btc_coexist
758 *btcoexist, IN boolean low_penalty_ra)
760 u8 h2c_parameter[6] = {0};
762 h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
764 if (low_penalty_ra) {
765 h2c_parameter[1] |= BIT(0);
767 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
768 h2c_parameter[3] = 0xf4; /* MCS7 or OFDM54 */
769 h2c_parameter[4] = 0xf5; /* MCS6 or OFDM48 */
770 h2c_parameter[5] = 0xf6; /* MCS5 or OFDM36 */
773 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
776 void halbtc8723b2ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
777 IN boolean force_exec, IN boolean low_penalty_ra)
779 coex_dm->cur_low_penalty_ra = low_penalty_ra;
782 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
785 halbtc8723b2ant_set_sw_penalty_tx_rate_adaptive(btcoexist,
786 coex_dm->cur_low_penalty_ra);
788 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
791 void halbtc8723b2ant_set_dac_swing_reg(IN struct btc_coexist *btcoexist,
796 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
797 "[BTCoex], Write SwDacSwing = 0x%x\n", level);
798 BTC_TRACE(trace_buf);
799 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
802 void halbtc8723b2ant_set_sw_full_time_dac_swing(IN struct btc_coexist
803 *btcoexist, IN boolean sw_dac_swing_on, IN u32 sw_dac_swing_lvl)
806 halbtc8723b2ant_set_dac_swing_reg(btcoexist, sw_dac_swing_lvl);
808 halbtc8723b2ant_set_dac_swing_reg(btcoexist, 0x18);
812 void halbtc8723b2ant_dac_swing(IN struct btc_coexist *btcoexist,
813 IN boolean force_exec, IN boolean dac_swing_on, IN u32 dac_swing_lvl)
815 coex_dm->cur_dac_swing_on = dac_swing_on;
816 coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
819 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
820 (coex_dm->pre_dac_swing_lvl ==
821 coex_dm->cur_dac_swing_lvl))
825 halbtc8723b2ant_set_sw_full_time_dac_swing(btcoexist, dac_swing_on,
828 coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
829 coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
832 void halbtc8723b2ant_set_adc_back_off(IN struct btc_coexist *btcoexist,
833 IN boolean adc_back_off)
836 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
837 "[BTCoex], BB BackOff Level On!\n");
838 BTC_TRACE(trace_buf);
839 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc05, 0x30, 0x3);
841 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
842 "[BTCoex], BB BackOff Level Off!\n");
843 BTC_TRACE(trace_buf);
844 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc05, 0x30, 0x1);
848 void halbtc8723b2ant_adc_back_off(IN struct btc_coexist *btcoexist,
849 IN boolean force_exec, IN boolean adc_back_off)
851 coex_dm->cur_adc_back_off = adc_back_off;
854 if (coex_dm->pre_adc_back_off == coex_dm->cur_adc_back_off)
857 halbtc8723b2ant_set_adc_back_off(btcoexist, coex_dm->cur_adc_back_off);
859 coex_dm->pre_adc_back_off = coex_dm->cur_adc_back_off;
862 void halbtc8723b2ant_set_agc_table(IN struct btc_coexist *btcoexist,
863 IN boolean agc_table_en)
865 u8 rssi_adjust_val = 0;
867 /* =================BB AGC Gain Table */
869 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
870 "[BTCoex], BB Agc Table On!\n");
871 BTC_TRACE(trace_buf);
872 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6e1A0001);
873 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6d1B0001);
874 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6c1C0001);
875 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6b1D0001);
876 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6a1E0001);
877 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x691F0001);
878 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x68200001);
880 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
881 "[BTCoex], BB Agc Table Off!\n");
882 BTC_TRACE(trace_buf);
883 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001);
884 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001);
885 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001);
886 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa71D0001);
887 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa61E0001);
888 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa51F0001);
889 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa4200001);
893 /* =================RF Gain */
894 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
896 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
897 "[BTCoex], Agc Table On!\n");
898 BTC_TRACE(trace_buf);
899 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff,
901 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff,
904 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
905 "[BTCoex], Agc Table Off!\n");
906 BTC_TRACE(trace_buf);
907 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff,
909 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff,
912 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
914 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
916 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
917 "[BTCoex], Agc Table On!\n");
918 BTC_TRACE(trace_buf);
919 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 0xfffff,
921 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 0xfffff,
924 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
925 "[BTCoex], Agc Table Off!\n");
926 BTC_TRACE(trace_buf);
927 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 0xfffff,
929 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 0xfffff,
932 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
934 /* set rssi_adjust_val for wifi module. */
937 btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON,
941 void halbtc8723b2ant_agc_table(IN struct btc_coexist *btcoexist,
942 IN boolean force_exec, IN boolean agc_table_en)
944 coex_dm->cur_agc_table_en = agc_table_en;
947 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
950 halbtc8723b2ant_set_agc_table(btcoexist, agc_table_en);
952 coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en;
955 void halbtc8723b2ant_sw_mechanism1(IN struct btc_coexist *btcoexist,
956 IN boolean shrink_rx_lpf, IN boolean low_penalty_ra,
957 IN boolean limited_dig, IN boolean bt_lna_constrain)
962 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
964 if(BTC_WIFI_BW_HT40 != wifi_bw)
967 shrink_rx_lpf = false;
971 /* halbtc8723b2ant_rf_shrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf); */
972 halbtc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
975 void halbtc8723b2ant_sw_mechanism2(IN struct btc_coexist *btcoexist,
976 IN boolean agc_table_shift, IN boolean adc_back_off,
977 IN boolean sw_dac_swing, IN u32 dac_swing_lvl)
979 /* halbtc8723b2ant_agc_table(btcoexist, NORMAL_EXEC, agc_table_shift); */
980 /* halbtc8723b2ant_adc_back_off(btcoexist, NORMAL_EXEC, adc_back_off); */
981 /* halbtc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing, dac_swing_lvl); */
984 void halbtc8723b2ant_set_coex_table(IN struct btc_coexist *btcoexist,
985 IN u32 val0x6c0, IN u32 val0x6c4, IN u32 val0x6c8, IN u8 val0x6cc)
987 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
989 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
991 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
993 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
996 void halbtc8723b2ant_coex_table(IN struct btc_coexist *btcoexist,
997 IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
998 IN u32 val0x6c8, IN u8 val0x6cc)
1000 coex_dm->cur_val0x6c0 = val0x6c0;
1001 coex_dm->cur_val0x6c4 = val0x6c4;
1002 coex_dm->cur_val0x6c8 = val0x6c8;
1003 coex_dm->cur_val0x6cc = val0x6cc;
1006 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1007 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1008 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1009 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1012 halbtc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1015 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1016 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1017 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1018 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1021 void halbtc8723b2ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
1022 IN boolean force_exec, IN u8 type)
1024 coex_sta->coex_table_type = type;
1028 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1029 0x55555555, 0x55555555, 0xffffff, 0x3);
1032 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1033 0x55555555, 0x5afa5afa, 0xffffff, 0x3);
1036 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1037 0x5ada5ada, 0x5ada5ada, 0xffffff, 0x3);
1040 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1041 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3);
1044 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1045 0xffffffff, 0xffffffff, 0xffffff, 0x3);
1048 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1049 0x5fff5fff, 0x5fff5fff, 0xffffff, 0x3);
1052 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1053 0x55ff55ff, 0x5a5a5a5a, 0xffffff, 0x3);
1056 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1057 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
1060 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1061 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
1064 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1065 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
1068 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1069 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
1072 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1073 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
1076 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1077 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
1080 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1081 0x5fff5fff, 0xaaaaaaaa, 0xffffff, 0x3);
1084 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1085 0x5fff5fff, 0x5ada5ada, 0xffffff, 0x3);
1088 halbtc8723b2ant_coex_table(btcoexist, force_exec,
1089 0x55dd55dd, 0xaaaaaaaa, 0xffffff, 0x3);
1096 void halbtc8723b2ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1099 u8 h2c_parameter[1] = {0};
1102 h2c_parameter[0] |= BIT(0); /* function enable */
1104 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1107 void halbtc8723b2ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1108 IN boolean force_exec, IN boolean enable)
1110 coex_dm->cur_ignore_wlan_act = enable;
1113 if (coex_dm->pre_ignore_wlan_act ==
1114 coex_dm->cur_ignore_wlan_act)
1117 halbtc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1119 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1122 void halbtc8723b2ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
1123 IN u8 lps_val, IN u8 rpwm_val)
1128 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1129 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1132 void halbtc8723b2ant_lps_rpwm(IN struct btc_coexist *btcoexist,
1133 IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
1135 coex_dm->cur_lps = lps_val;
1136 coex_dm->cur_rpwm = rpwm_val;
1139 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1140 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1143 halbtc8723b2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1145 coex_dm->pre_lps = coex_dm->cur_lps;
1146 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1149 void halbtc8723b2ant_ps_tdma_check_for_power_save_state(
1150 IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
1153 u8 h2c_parameter[5] = {0x0, 0, 0, 48, 0};
1155 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1157 if (lps_mode) { /* already under LPS state */
1159 /* keep state under LPS, do nothing. */
1161 /* will leave LPS state, turn off psTdma first */
1162 /* halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1164 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1167 } else { /* NO PS state */
1169 /* will enter LPS state, turn off psTdma first */
1170 /* halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1172 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1175 /* keep state under NO PS state, do nothing. */
1180 void halbtc8723b2ant_power_save_state(IN struct btc_coexist *btcoexist,
1181 IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
1183 boolean low_pwr_disable = false;
1186 case BTC_PS_WIFI_NATIVE:
1187 /* recover to original 32k low power setting */
1188 low_pwr_disable = false;
1189 btcoexist->btc_set(btcoexist,
1190 BTC_SET_ACT_DISABLE_LOW_POWER,
1192 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
1194 coex_sta->force_lps_on = false;
1197 halbtc8723b2ant_ps_tdma_check_for_power_save_state(
1199 halbtc8723b2ant_lps_rpwm(btcoexist, NORMAL_EXEC,
1201 /* when coex force to enter LPS, do not enter 32k low power. */
1202 low_pwr_disable = true;
1203 btcoexist->btc_set(btcoexist,
1204 BTC_SET_ACT_DISABLE_LOW_POWER,
1206 /* power save must executed before psTdma. */
1207 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
1209 coex_sta->force_lps_on = true;
1211 case BTC_PS_LPS_OFF:
1212 halbtc8723b2ant_ps_tdma_check_for_power_save_state(
1214 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1216 coex_sta->force_lps_on = false;
1224 void halbtc8723b2ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
1225 IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
1227 u8 h2c_parameter[5] = {0};
1228 u8 real_byte1 = byte1, real_byte5 = byte5;
1229 boolean ap_enable = false;
1231 if ((coex_sta->a2dp_exist) && (coex_sta->hid_exist))
1232 byte5 = byte5 | 0x1;
1235 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1239 if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1240 real_byte1 &= ~BIT(4);
1241 real_byte1 |= BIT(5);
1243 real_byte5 |= BIT(5);
1244 real_byte5 &= ~BIT(6);
1246 halbtc8723b2ant_power_save_state(btcoexist,
1247 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1249 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1250 halbtc8723b2ant_power_save_state(btcoexist,
1251 BTC_PS_LPS_ON, 0x50, 0x4);
1254 halbtc8723b2ant_power_save_state(btcoexist,
1255 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1258 h2c_parameter[0] = byte1;
1259 h2c_parameter[1] = byte2;
1260 h2c_parameter[2] = byte3;
1261 h2c_parameter[3] = byte4;
1262 h2c_parameter[4] = byte5;
1264 coex_dm->ps_tdma_para[0] = byte1;
1265 coex_dm->ps_tdma_para[1] = byte2;
1266 coex_dm->ps_tdma_para[2] = byte3;
1267 coex_dm->ps_tdma_para[3] = byte4;
1268 coex_dm->ps_tdma_para[4] = byte5;
1270 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1273 void halbtc8723b2ant_ps_tdma(IN struct btc_coexist *btcoexist,
1274 IN boolean force_exec, IN boolean turn_on, IN u8 type)
1276 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
1277 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
1278 u8 wifi_rssi_state1, bt_rssi_state;
1279 s8 wifi_duration_adjust = 0x0;
1280 u8 psTdmaByte4Modify = 0x0;
1281 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1283 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
1284 &prewifi_rssi_state, 2, BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES
1285 - coex_dm->switch_thres_offset, 0);
1286 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
1287 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1288 coex_dm->switch_thres_offset, 0);
1290 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1291 "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1292 (force_exec ? "force to" : ""), (turn_on ? "ON" : "OFF"), type);
1293 BTC_TRACE(trace_buf);
1294 coex_dm->cur_ps_tdma_on = turn_on;
1295 coex_dm->cur_ps_tdma = type;
1297 if (!(BTC_RSSI_HIGH(wifi_rssi_state1) &&
1298 BTC_RSSI_HIGH(bt_rssi_state)) && turn_on)
1299 /* if (halbtc8723b2ant_CoexSwitchThresCheck(btcoexist) && turn_on) */
1301 type = type + 100; /* for WiFi RSSI low or BT RSSI low */
1302 coex_dm->is_switch_to_1dot5_ant = true;
1304 coex_dm->is_switch_to_1dot5_ant = false;
1308 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1309 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1313 if (coex_sta->scan_ap_num <= 5) {
1314 if (coex_sta->a2dp_bit_pool >= 45)
1315 wifi_duration_adjust = -15;
1316 else if (coex_sta->a2dp_bit_pool >= 35)
1317 wifi_duration_adjust = -10;
1319 wifi_duration_adjust = 5;
1320 } else if (coex_sta->scan_ap_num <= 20) {
1321 if (coex_sta->a2dp_bit_pool >= 45)
1322 wifi_duration_adjust = -15;
1323 else if (coex_sta->a2dp_bit_pool >= 35)
1324 wifi_duration_adjust = -10;
1326 wifi_duration_adjust = 0;
1327 } else if (coex_sta->scan_ap_num <= 40) {
1328 if (coex_sta->a2dp_bit_pool >= 45)
1329 wifi_duration_adjust = -15;
1330 else if (coex_sta->a2dp_bit_pool >= 35)
1331 wifi_duration_adjust = -10;
1333 wifi_duration_adjust = -5;
1335 if (coex_sta->a2dp_bit_pool >= 45)
1336 wifi_duration_adjust = -15;
1337 else if (coex_sta->a2dp_bit_pool >= 35)
1338 wifi_duration_adjust = -10;
1340 wifi_duration_adjust = -10;
1343 if ((bt_link_info->slave_role == true) && (bt_link_info->a2dp_exist))
1345 0x1; /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1352 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1353 0x3c + wifi_duration_adjust, 0x03, 0xf1,
1354 0x90 | psTdmaByte4Modify);
1357 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1358 0x2d + wifi_duration_adjust, 0x03, 0xf1,
1359 0x90 | psTdmaByte4Modify);
1362 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1363 0x1c, 0x3, 0xf1, 0x90 |
1367 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1368 0x10, 0x03, 0xf1, 0x90 |
1372 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1373 0x3c + wifi_duration_adjust, 0x3, 0x70,
1374 0x90 | psTdmaByte4Modify);
1377 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1378 0x2d + wifi_duration_adjust, 0x3, 0x70,
1379 0x90 | psTdmaByte4Modify);
1382 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1383 0x1c, 0x3, 0x70, 0x90 |
1387 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xa3,
1388 0x10, 0x3, 0x70, 0x90 |
1393 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1394 0x3c + wifi_duration_adjust, 0x03, 0xf1,
1395 0x90 | psTdmaByte4Modify);
1397 /* Bryant Modify for BT no-profile busy case */
1398 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1399 0x3c + wifi_duration_adjust, 0x03, 0xf1,
1404 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1405 0x2d + wifi_duration_adjust, 0x03, 0xf1,
1406 0x90 | psTdmaByte4Modify);
1409 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1410 0x1c, 0x3, 0xf1, 0x90 |
1414 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1415 0x10, 0x3, 0xf1, 0x90 |
1420 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1421 0x3c + wifi_duration_adjust, 0x3, 0x70,
1422 0x90 | psTdmaByte4Modify);
1424 /* Bryant Modify for BT no-profile busy case */
1425 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1426 0x3c + wifi_duration_adjust, 0x3, 0x70,
1430 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1431 0x2d + wifi_duration_adjust, 0x3, 0x70,
1432 0x90 | psTdmaByte4Modify);
1435 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1436 0x1c, 0x3, 0x70, 0x90 |
1440 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1441 0x10, 0x3, 0x70, 0x90 |
1445 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xa3,
1446 0x2f, 0x2f, 0x60, 0x90);
1449 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1450 0x5, 0x5, 0xe1, 0x90);
1453 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1454 0x25, 0x25, 0xe1, 0x90);
1457 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1458 0x25, 0x25, 0x60, 0x90);
1461 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1462 0x15, 0x03, 0x70, 0x90);
1465 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1466 0x35, 0x03, 0xf1, 0x90);
1469 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1470 0x35, 0x03, 0x71, 0x10);
1474 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1475 0x30, 0x03, 0x71, 0x10);
1479 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1480 0x1c, 0x3, 0xf1, 0x91);
1484 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1485 0x3c + wifi_duration_adjust, 0x03, 0xf1,
1492 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xd3,
1493 0x3a + wifi_duration_adjust, 0x03, 0x70,
1494 0x50 | psTdmaByte4Modify);
1500 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xd3,
1501 0x2d + wifi_duration_adjust, 0x03, 0x70,
1502 0x50 | psTdmaByte4Modify);
1508 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xd3,
1509 0x1c, 0x03, 0x70, 0x50 |
1516 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xd3,
1517 0x10, 0x03, 0x70, 0x50 |
1521 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1522 0x3c, 0x03, 0xf1, 0x90 |
1526 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1527 0x3c, 0x03, 0x70, 0x90 |
1531 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1532 0x15, 0x03, 0x70, 0x90 |
1536 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1537 0x35, 0x03, 0x71, 0x11);
1540 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xe3,
1541 0x35, 0x03, 0x71, 0x10);
1544 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xd3,
1545 0x30, 0x03, 0x70, 0x51);
1549 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0xd3,
1550 0x1c, 0x3, 0x70, 0x51);
1555 /* disable PS tdma */
1558 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0x0,
1559 0x0, 0x0, 0x40, 0x0);
1562 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0x0,
1563 0x0, 0x0, 0x48, 0x0);
1566 halbtc8723b2ant_set_fw_pstdma(btcoexist, 0x0,
1567 0x0, 0x0, 0x40, 0x0);
1572 /* update pre state */
1573 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1574 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1578 void halbtc8723b2ant_set_ant_path(IN struct btc_coexist *btcoexist,
1579 IN u8 ant_pos_type, IN boolean init_hwcfg, IN boolean wifi_off)
1581 struct btc_board_info *board_info = &btcoexist->board_info;
1582 u32 fw_ver = 0, u32tmp = 0, cnt_bt_cal_chk = 0;
1583 boolean pg_ext_switch = false;
1584 boolean use_ext_switch = false;
1585 u8 h2c_parameter[2] = {0};
1587 boolean is_fw_ready;
1589 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
1590 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER,
1591 &fw_ver); /* [31:16]=fw ver, [15:0]=fw sub ver */
1593 if ((fw_ver > 0 && fw_ver < 0xc0000) || pg_ext_switch)
1594 use_ext_switch = true;
1597 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
1598 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
1599 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
1600 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
1601 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
1603 if (fw_ver >= 0x180000) {
1604 /* Use H2C to set GNT_BT to High to avoid A2DP click */
1605 h2c_parameter[0] = 1;
1606 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1611 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_FW_READY, &is_fw_ready);
1612 if (is_fw_ready == false)
1615 if (btcoexist->btc_read_1byte(btcoexist,
1620 if (cnt_bt_cal_chk > 20)
1624 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
1625 u32tmp_1[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
1626 if ((u32tmp_1[0] == 0x40) || (u32tmp_1[0] == 0x240))
1627 btcoexist->btc_write_4byte(btcoexist, 0x948,
1630 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
1632 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1633 0x0); /* WiFi TRx Mask off */
1634 /* remove due to interrupt is disabled that polling c2h will fail and delay 100ms. */
1635 /* btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x01); */ /*BT TRx Mask off */
1637 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1638 /* tell firmware "no antenna inverse" */
1639 h2c_parameter[0] = 0;
1641 /* tell firmware "antenna inverse" */
1642 h2c_parameter[0] = 1;
1645 if (use_ext_switch) {
1646 /* ext switch type */
1647 h2c_parameter[1] = 1;
1649 /* int switch type */
1650 h2c_parameter[1] = 0;
1652 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, h2c_parameter);
1654 if (fw_ver >= 0x180000) {
1655 /* Use H2C to set GNT_BT to "Control by PTA"*/
1656 h2c_parameter[0] = 0;
1657 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1662 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_FW_READY, &is_fw_ready);
1663 if (is_fw_ready == false)
1666 if (btcoexist->btc_read_1byte(btcoexist,
1671 if (cnt_bt_cal_chk > 20)
1675 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
1678 /* ext switch setting */
1679 if (use_ext_switch) {
1681 /* 0x4c[23]=0, 0x4c[24]=1 Antenna control by WL/BT */
1682 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1685 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1687 u32tmp_1[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
1688 if ((u32tmp_1[0] == 0x40) || (u32tmp_1[0] == 0x240))
1689 btcoexist->btc_write_4byte(btcoexist, 0x948,
1692 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
1694 switch (ant_pos_type) {
1695 case BTC_ANT_WIFI_AT_MAIN:
1696 btcoexist->btc_write_1byte_bitmask(btcoexist,
1698 0x1); /* ext switch main at wifi */
1700 case BTC_ANT_WIFI_AT_AUX:
1701 btcoexist->btc_write_1byte_bitmask(btcoexist,
1703 0x2); /* ext switch aux at wifi */
1706 } else { /* internal switch */
1708 /* 0x4c[23]=0, 0x4c[24]=1 Antenna control by WL/BT */
1709 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1712 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1715 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
1716 0x0); /* fixed external switch S1->Main, S0->Aux */
1717 switch (ant_pos_type) {
1718 case BTC_ANT_WIFI_AT_MAIN:
1719 u32tmp_1[0] = btcoexist->btc_read_4byte(btcoexist,
1721 if ((u32tmp_1[0] == 0x40) || (u32tmp_1[0] == 0x240))
1722 btcoexist->btc_write_4byte(btcoexist, 0x948,
1725 btcoexist->btc_write_4byte(btcoexist, 0x948,
1728 case BTC_ANT_WIFI_AT_AUX:
1729 u32tmp_1[0] = btcoexist->btc_read_4byte(btcoexist,
1731 if ((u32tmp_1[0] == 0x40) || (u32tmp_1[0] == 0x240))
1732 btcoexist->btc_write_4byte(btcoexist, 0x948,
1735 btcoexist->btc_write_4byte(btcoexist, 0x948,
1742 boolean halbtc8723b2ant_CoexSwitchThresCheck(IN struct btc_coexist *btcoexist)
1744 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
1745 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
1746 u8 wifi_rssi_state1, bt_rssi_state;
1750 btcoexist->btc_get(btcoexist, BTC_GET_U4_VENDOR, &vendor);
1752 /* if (vendor == BTC_VENDOR_LENOVO) */
1755 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
1756 &prewifi_rssi_state, 2, BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES
1757 - coex_dm->switch_thres_offset, 0);
1758 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
1759 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1760 coex_dm->switch_thres_offset, 0);
1762 if (BTC_RSSI_LOW(wifi_rssi_state1) || BTC_RSSI_LOW(bt_rssi_state))
1770 void halbtc8723b2ant_coex_all_off(IN struct btc_coexist *btcoexist)
1773 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1774 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1775 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1778 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1779 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1782 /* btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
1783 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1786 void halbtc8723b2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
1788 /* force to reset coex mechanism */
1789 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1791 halbtc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1792 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1793 halbtc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 0);
1795 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1796 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1798 coex_sta->pop_event_cnt = 0;
1802 void halbtc8723b2ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
1804 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
1805 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
1806 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
1807 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1808 boolean wifi_connected = false;
1809 boolean low_pwr_disable = true;
1810 boolean scan = false, link = false, roam = false;
1811 boolean wifi_busy = false;
1814 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
1815 &prewifi_rssi_state, 2, 15, 0);
1816 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
1817 &prewifi_rssi_state1, 2,
1818 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1819 coex_dm->switch_thres_offset, 0);
1820 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
1821 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1822 coex_dm->switch_thres_offset, 0);
1824 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1826 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1829 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1830 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1831 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1832 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1835 if (coex_sta->bt_abnormal_scan) {
1836 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1838 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
1839 } else if (scan || link || roam) {
1840 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1841 "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1842 BTC_TRACE(trace_buf);
1843 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
1845 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1846 } else if (wifi_connected) {
1847 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1848 "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1849 BTC_TRACE(trace_buf);
1850 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
1854 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1857 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
1859 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1860 "[BTCoex], Wifi no-link + BT Inq/Page!!\n");
1861 BTC_TRACE(trace_buf);
1862 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1863 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1866 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1867 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1869 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1870 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1872 coex_dm->need_recover0x948 = true;
1873 coex_dm->backup0x948 = btcoexist->btc_read_4byte(btcoexist, 0x948);
1875 halbtc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_AUX, false, false);
1880 void halbtc8723b2ant_action_wifi_link_process(IN struct btc_coexist *btcoexist)
1885 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1886 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1888 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1889 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1892 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
1893 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1894 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1896 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1897 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x76e=0x%x\n",
1898 u32tmp, u8tmpa, u8tmpb);
1899 BTC_TRACE(trace_buf);
1902 boolean halbtc8723b2ant_action_wifi_idle_process(IN struct btc_coexist
1905 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
1906 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
1907 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
1908 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1911 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
1912 &prewifi_rssi_state, 2, 15, 0);
1913 /* wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist, 1, 2, BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES-coex_dm->switch_thres_offset-coex_dm->switch_thres_offset, 0); */
1914 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
1915 &prewifi_rssi_state1, 2,
1916 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1917 coex_dm->switch_thres_offset - coex_dm->switch_thres_offset, 0);
1918 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
1919 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1920 coex_dm->switch_thres_offset - coex_dm->switch_thres_offset, 0);
1922 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1924 /* define the office environment */
1925 if (BTC_RSSI_HIGH(wifi_rssi_state1) &&
1926 (coex_sta->hid_exist == true) &&
1927 (coex_sta->a2dp_exist == true)) {
1929 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1930 "[BTCoex], Wifi idle process for BT HID+A2DP exist!!\n");
1931 BTC_TRACE(trace_buf);
1933 halbtc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1934 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1937 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false,
1939 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false,
1942 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1944 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1949 halbtc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1955 boolean halbtc8723b2ant_is_common_action(IN struct btc_coexist *btcoexist)
1957 boolean common = false, wifi_connected = false, wifi_busy = false;
1958 boolean bt_hs_on = false, low_pwr_disable = false;
1959 boolean asus_8723b = false;
1961 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1962 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1964 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1966 if (!wifi_connected) {
1967 low_pwr_disable = false;
1968 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1970 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
1973 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1974 "[BTCoex], Wifi non-connected idle!!\n");
1975 BTC_TRACE(trace_buf);
1977 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1979 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1981 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1982 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1983 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1985 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false,
1987 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false,
1992 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1993 coex_dm->bt_status) {
1994 low_pwr_disable = false;
1995 btcoexist->btc_set(btcoexist,
1996 BTC_SET_ACT_DISABLE_LOW_POWER,
1998 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
2001 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2002 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
2003 BTC_TRACE(trace_buf);
2005 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2007 halbtc8723b2ant_coex_table_with_type(btcoexist,
2010 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
2012 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2014 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2016 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
2019 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
2023 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
2024 coex_dm->bt_status) {
2025 low_pwr_disable = true;
2026 btcoexist->btc_set(btcoexist,
2027 BTC_SET_ACT_DISABLE_LOW_POWER,
2032 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2033 "[BTCoex], Wifi connected + BT connected-idle!!\n");
2034 BTC_TRACE(trace_buf);
2035 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
2038 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2040 halbtc8723b2ant_coex_table_with_type(btcoexist,
2042 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
2044 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2046 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2048 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
2050 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
2055 low_pwr_disable = true;
2056 btcoexist->btc_set(btcoexist,
2057 BTC_SET_ACT_DISABLE_LOW_POWER,
2061 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2062 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
2063 BTC_TRACE(trace_buf);
2064 /* btcoexist->btc_get(btcoexist,
2065 BTC_GET_BL_IS_ASUS_8723B, &asus_8723b);
2069 common = halbtc8723b2ant_action_wifi_idle_process(
2073 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2074 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
2075 BTC_TRACE(trace_buf);
2076 /* common = false; */
2077 common = halbtc8723b2ant_action_wifi_idle_process(
2085 void halbtc8723b2ant_tdma_duration_adjust(IN struct btc_coexist *btcoexist,
2086 IN boolean sco_hid, IN boolean tx_pause, IN u8 max_interval)
2088 static s32 up, dn, m, n, wait_count;
2089 s32 result; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
2092 if (!coex_dm->auto_tdma_adjust) {
2093 coex_dm->auto_tdma_adjust = true;
2097 if (max_interval == 1) {
2098 halbtc8723b2ant_ps_tdma(
2099 btcoexist, NORMAL_EXEC,
2101 coex_dm->ps_tdma_du_adj_type =
2103 } else if (max_interval == 2) {
2104 halbtc8723b2ant_ps_tdma(
2105 btcoexist, NORMAL_EXEC,
2107 coex_dm->ps_tdma_du_adj_type =
2109 } else if (max_interval == 3) {
2110 halbtc8723b2ant_ps_tdma(
2111 btcoexist, NORMAL_EXEC,
2113 coex_dm->ps_tdma_du_adj_type =
2116 halbtc8723b2ant_ps_tdma(
2117 btcoexist, NORMAL_EXEC,
2119 coex_dm->ps_tdma_du_adj_type =
2123 if (max_interval == 1) {
2124 halbtc8723b2ant_ps_tdma(
2125 btcoexist, NORMAL_EXEC,
2127 coex_dm->ps_tdma_du_adj_type =
2129 } else if (max_interval == 2) {
2130 halbtc8723b2ant_ps_tdma(
2131 btcoexist, NORMAL_EXEC,
2133 coex_dm->ps_tdma_du_adj_type =
2135 } else if (max_interval == 3) {
2136 halbtc8723b2ant_ps_tdma(
2137 btcoexist, NORMAL_EXEC,
2139 coex_dm->ps_tdma_du_adj_type =
2142 halbtc8723b2ant_ps_tdma(
2143 btcoexist, NORMAL_EXEC,
2145 coex_dm->ps_tdma_du_adj_type =
2151 if (max_interval == 1) {
2152 halbtc8723b2ant_ps_tdma(
2153 btcoexist, NORMAL_EXEC,
2155 coex_dm->ps_tdma_du_adj_type =
2157 } else if (max_interval == 2) {
2158 halbtc8723b2ant_ps_tdma(
2159 btcoexist, NORMAL_EXEC,
2161 coex_dm->ps_tdma_du_adj_type =
2163 } else if (max_interval == 3) {
2164 halbtc8723b2ant_ps_tdma(
2165 btcoexist, NORMAL_EXEC,
2167 coex_dm->ps_tdma_du_adj_type =
2170 halbtc8723b2ant_ps_tdma(
2171 btcoexist, NORMAL_EXEC,
2173 coex_dm->ps_tdma_du_adj_type =
2177 if (max_interval == 1) {
2178 halbtc8723b2ant_ps_tdma(
2179 btcoexist, NORMAL_EXEC,
2181 coex_dm->ps_tdma_du_adj_type =
2183 } else if (max_interval == 2) {
2184 halbtc8723b2ant_ps_tdma(
2185 btcoexist, NORMAL_EXEC,
2187 coex_dm->ps_tdma_du_adj_type =
2189 } else if (max_interval == 3) {
2190 halbtc8723b2ant_ps_tdma(
2191 btcoexist, NORMAL_EXEC,
2193 coex_dm->ps_tdma_du_adj_type =
2196 halbtc8723b2ant_ps_tdma(
2197 btcoexist, NORMAL_EXEC,
2199 coex_dm->ps_tdma_du_adj_type =
2213 /* acquire the BT TRx retry count from BT_Info byte2 */
2214 retry_count = coex_sta->bt_retry_cnt;
2216 if ((coex_sta->low_priority_tx) > 1050 ||
2217 (coex_sta->low_priority_rx) > 1250)
2224 0) { /* no retry in the last 2-second duration */
2231 if (up >= n) { /* if retry count during continuous n*2 seconds is 0, enlarge WiFi duration */
2238 } else if (retry_count <=
2239 3) { /* <=3 retry in the last 2-second duration */
2246 if (dn == 2) {/* if continuous 2 retry count(every 2 seconds) >0 and < 3, reduce WiFi duration */
2247 if (wait_count <= 2)
2248 m++; /* to avoid loop between the two levels */
2252 if (m >= 20) /* maximum of m = 20 ' will recheck if need to adjust wifi duration in maximum time interval 120 seconds */
2261 } else { /* retry count > 3, once retry count > 3, to reduce WiFi duration */
2262 if (wait_count == 1)
2263 m++; /* to avoid loop between the two levels */
2267 if (m >= 20) /* maximum of m = 20 ' will recheck if need to adjust wifi duration in maximum time interval 120 seconds */
2277 if (max_interval == 1) {
2279 if (coex_dm->cur_ps_tdma == 71) {
2280 halbtc8723b2ant_ps_tdma(btcoexist,
2281 NORMAL_EXEC, true, 5);
2282 coex_dm->ps_tdma_du_adj_type = 5;
2283 } else if (coex_dm->cur_ps_tdma == 1) {
2284 halbtc8723b2ant_ps_tdma(btcoexist,
2285 NORMAL_EXEC, true, 5);
2286 coex_dm->ps_tdma_du_adj_type = 5;
2287 } else if (coex_dm->cur_ps_tdma == 2) {
2288 halbtc8723b2ant_ps_tdma(btcoexist,
2289 NORMAL_EXEC, true, 6);
2290 coex_dm->ps_tdma_du_adj_type = 6;
2291 } else if (coex_dm->cur_ps_tdma == 3) {
2292 halbtc8723b2ant_ps_tdma(btcoexist,
2293 NORMAL_EXEC, true, 7);
2294 coex_dm->ps_tdma_du_adj_type = 7;
2295 } else if (coex_dm->cur_ps_tdma == 4) {
2296 halbtc8723b2ant_ps_tdma(btcoexist,
2297 NORMAL_EXEC, true, 8);
2298 coex_dm->ps_tdma_du_adj_type = 8;
2300 if (coex_dm->cur_ps_tdma == 9) {
2301 halbtc8723b2ant_ps_tdma(btcoexist,
2302 NORMAL_EXEC, true, 13);
2303 coex_dm->ps_tdma_du_adj_type = 13;
2304 } else if (coex_dm->cur_ps_tdma == 10) {
2305 halbtc8723b2ant_ps_tdma(btcoexist,
2306 NORMAL_EXEC, true, 14);
2307 coex_dm->ps_tdma_du_adj_type = 14;
2308 } else if (coex_dm->cur_ps_tdma == 11) {
2309 halbtc8723b2ant_ps_tdma(btcoexist,
2310 NORMAL_EXEC, true, 15);
2311 coex_dm->ps_tdma_du_adj_type = 15;
2312 } else if (coex_dm->cur_ps_tdma == 12) {
2313 halbtc8723b2ant_ps_tdma(btcoexist,
2314 NORMAL_EXEC, true, 16);
2315 coex_dm->ps_tdma_du_adj_type = 16;
2319 if (coex_dm->cur_ps_tdma == 5) {
2320 halbtc8723b2ant_ps_tdma(
2321 btcoexist, NORMAL_EXEC,
2323 coex_dm->ps_tdma_du_adj_type =
2325 } else if (coex_dm->cur_ps_tdma == 6) {
2326 halbtc8723b2ant_ps_tdma(
2327 btcoexist, NORMAL_EXEC,
2329 coex_dm->ps_tdma_du_adj_type =
2331 } else if (coex_dm->cur_ps_tdma == 7) {
2332 halbtc8723b2ant_ps_tdma(
2333 btcoexist, NORMAL_EXEC,
2335 coex_dm->ps_tdma_du_adj_type =
2337 } else if (coex_dm->cur_ps_tdma == 13) {
2338 halbtc8723b2ant_ps_tdma(
2339 btcoexist, NORMAL_EXEC,
2341 coex_dm->ps_tdma_du_adj_type =
2343 } else if (coex_dm->cur_ps_tdma == 14) {
2344 halbtc8723b2ant_ps_tdma(
2345 btcoexist, NORMAL_EXEC,
2347 coex_dm->ps_tdma_du_adj_type =
2349 } else if (coex_dm->cur_ps_tdma == 15) {
2350 halbtc8723b2ant_ps_tdma(
2351 btcoexist, NORMAL_EXEC,
2353 coex_dm->ps_tdma_du_adj_type =
2356 } else if (result == 1) {
2357 if (coex_dm->cur_ps_tdma == 8) {
2358 halbtc8723b2ant_ps_tdma(
2359 btcoexist, NORMAL_EXEC,
2361 coex_dm->ps_tdma_du_adj_type =
2363 } else if (coex_dm->cur_ps_tdma == 7) {
2364 halbtc8723b2ant_ps_tdma(
2365 btcoexist, NORMAL_EXEC,
2367 coex_dm->ps_tdma_du_adj_type =
2369 } else if (coex_dm->cur_ps_tdma == 6) {
2370 halbtc8723b2ant_ps_tdma(
2371 btcoexist, NORMAL_EXEC,
2373 coex_dm->ps_tdma_du_adj_type =
2375 } else if (coex_dm->cur_ps_tdma == 16) {
2376 halbtc8723b2ant_ps_tdma(
2377 btcoexist, NORMAL_EXEC,
2379 coex_dm->ps_tdma_du_adj_type =
2381 } else if (coex_dm->cur_ps_tdma == 15) {
2382 halbtc8723b2ant_ps_tdma(
2383 btcoexist, NORMAL_EXEC,
2385 coex_dm->ps_tdma_du_adj_type =
2387 } else if (coex_dm->cur_ps_tdma == 14) {
2388 halbtc8723b2ant_ps_tdma(
2389 btcoexist, NORMAL_EXEC,
2391 coex_dm->ps_tdma_du_adj_type =
2396 if (coex_dm->cur_ps_tdma == 5) {
2397 halbtc8723b2ant_ps_tdma(btcoexist,
2398 NORMAL_EXEC, true, 71);
2399 coex_dm->ps_tdma_du_adj_type = 71;
2400 } else if (coex_dm->cur_ps_tdma == 6) {
2401 halbtc8723b2ant_ps_tdma(btcoexist,
2402 NORMAL_EXEC, true, 2);
2403 coex_dm->ps_tdma_du_adj_type = 2;
2404 } else if (coex_dm->cur_ps_tdma == 7) {
2405 halbtc8723b2ant_ps_tdma(btcoexist,
2406 NORMAL_EXEC, true, 3);
2407 coex_dm->ps_tdma_du_adj_type = 3;
2408 } else if (coex_dm->cur_ps_tdma == 8) {
2409 halbtc8723b2ant_ps_tdma(btcoexist,
2410 NORMAL_EXEC, true, 4);
2411 coex_dm->ps_tdma_du_adj_type = 4;
2413 if (coex_dm->cur_ps_tdma == 13) {
2414 halbtc8723b2ant_ps_tdma(btcoexist,
2415 NORMAL_EXEC, true, 9);
2416 coex_dm->ps_tdma_du_adj_type = 9;
2417 } else if (coex_dm->cur_ps_tdma == 14) {
2418 halbtc8723b2ant_ps_tdma(btcoexist,
2419 NORMAL_EXEC, true, 10);
2420 coex_dm->ps_tdma_du_adj_type = 10;
2421 } else if (coex_dm->cur_ps_tdma == 15) {
2422 halbtc8723b2ant_ps_tdma(btcoexist,
2423 NORMAL_EXEC, true, 11);
2424 coex_dm->ps_tdma_du_adj_type = 11;
2425 } else if (coex_dm->cur_ps_tdma == 16) {
2426 halbtc8723b2ant_ps_tdma(btcoexist,
2427 NORMAL_EXEC, true, 12);
2428 coex_dm->ps_tdma_du_adj_type = 12;
2432 if (coex_dm->cur_ps_tdma == 71) {
2433 halbtc8723b2ant_ps_tdma(
2434 btcoexist, NORMAL_EXEC,
2436 coex_dm->ps_tdma_du_adj_type =
2438 } else if (coex_dm->cur_ps_tdma == 1) {
2439 halbtc8723b2ant_ps_tdma(
2440 btcoexist, NORMAL_EXEC,
2442 coex_dm->ps_tdma_du_adj_type =
2444 } else if (coex_dm->cur_ps_tdma == 2) {
2445 halbtc8723b2ant_ps_tdma(
2446 btcoexist, NORMAL_EXEC,
2448 coex_dm->ps_tdma_du_adj_type =
2450 } else if (coex_dm->cur_ps_tdma == 3) {
2451 halbtc8723b2ant_ps_tdma(
2452 btcoexist, NORMAL_EXEC,
2454 coex_dm->ps_tdma_du_adj_type =
2456 } else if (coex_dm->cur_ps_tdma == 9) {
2457 halbtc8723b2ant_ps_tdma(
2458 btcoexist, NORMAL_EXEC,
2460 coex_dm->ps_tdma_du_adj_type =
2462 } else if (coex_dm->cur_ps_tdma == 10) {
2463 halbtc8723b2ant_ps_tdma(
2464 btcoexist, NORMAL_EXEC,
2466 coex_dm->ps_tdma_du_adj_type =
2468 } else if (coex_dm->cur_ps_tdma == 11) {
2469 halbtc8723b2ant_ps_tdma(
2470 btcoexist, NORMAL_EXEC,
2472 coex_dm->ps_tdma_du_adj_type =
2475 } else if (result == 1) {
2476 if (coex_dm->cur_ps_tdma == 4) {
2477 halbtc8723b2ant_ps_tdma(
2478 btcoexist, NORMAL_EXEC,
2480 coex_dm->ps_tdma_du_adj_type =
2482 } else if (coex_dm->cur_ps_tdma == 3) {
2483 halbtc8723b2ant_ps_tdma(
2484 btcoexist, NORMAL_EXEC,
2486 coex_dm->ps_tdma_du_adj_type =
2488 } else if (coex_dm->cur_ps_tdma == 2) {
2489 halbtc8723b2ant_ps_tdma(
2490 btcoexist, NORMAL_EXEC,
2492 coex_dm->ps_tdma_du_adj_type =
2494 } else if (coex_dm->cur_ps_tdma == 1) {
2495 halbtc8723b2ant_ps_tdma(
2496 btcoexist, NORMAL_EXEC,
2498 coex_dm->ps_tdma_du_adj_type =
2500 } else if (coex_dm->cur_ps_tdma == 12) {
2501 halbtc8723b2ant_ps_tdma(
2502 btcoexist, NORMAL_EXEC,
2504 coex_dm->ps_tdma_du_adj_type =
2506 } else if (coex_dm->cur_ps_tdma == 11) {
2507 halbtc8723b2ant_ps_tdma(
2508 btcoexist, NORMAL_EXEC,
2510 coex_dm->ps_tdma_du_adj_type =
2512 } else if (coex_dm->cur_ps_tdma == 10) {
2513 halbtc8723b2ant_ps_tdma(
2514 btcoexist, NORMAL_EXEC,
2516 coex_dm->ps_tdma_du_adj_type =
2521 } else if (max_interval == 2) {
2523 if (coex_dm->cur_ps_tdma == 1) {
2524 halbtc8723b2ant_ps_tdma(btcoexist,
2525 NORMAL_EXEC, true, 6);
2526 coex_dm->ps_tdma_du_adj_type = 6;
2527 } else if (coex_dm->cur_ps_tdma == 2) {
2528 halbtc8723b2ant_ps_tdma(btcoexist,
2529 NORMAL_EXEC, true, 6);
2530 coex_dm->ps_tdma_du_adj_type = 6;
2531 } else if (coex_dm->cur_ps_tdma == 3) {
2532 halbtc8723b2ant_ps_tdma(btcoexist,
2533 NORMAL_EXEC, true, 7);
2534 coex_dm->ps_tdma_du_adj_type = 7;
2535 } else if (coex_dm->cur_ps_tdma == 4) {
2536 halbtc8723b2ant_ps_tdma(btcoexist,
2537 NORMAL_EXEC, true, 8);
2538 coex_dm->ps_tdma_du_adj_type = 8;
2540 if (coex_dm->cur_ps_tdma == 9) {
2541 halbtc8723b2ant_ps_tdma(btcoexist,
2542 NORMAL_EXEC, true, 14);
2543 coex_dm->ps_tdma_du_adj_type = 14;
2544 } else if (coex_dm->cur_ps_tdma == 10) {
2545 halbtc8723b2ant_ps_tdma(btcoexist,
2546 NORMAL_EXEC, true, 14);
2547 coex_dm->ps_tdma_du_adj_type = 14;
2548 } else if (coex_dm->cur_ps_tdma == 11) {
2549 halbtc8723b2ant_ps_tdma(btcoexist,
2550 NORMAL_EXEC, true, 15);
2551 coex_dm->ps_tdma_du_adj_type = 15;
2552 } else if (coex_dm->cur_ps_tdma == 12) {
2553 halbtc8723b2ant_ps_tdma(btcoexist,
2554 NORMAL_EXEC, true, 16);
2555 coex_dm->ps_tdma_du_adj_type = 16;
2558 if (coex_dm->cur_ps_tdma == 5) {
2559 halbtc8723b2ant_ps_tdma(
2560 btcoexist, NORMAL_EXEC,
2562 coex_dm->ps_tdma_du_adj_type =
2564 } else if (coex_dm->cur_ps_tdma == 6) {
2565 halbtc8723b2ant_ps_tdma(
2566 btcoexist, NORMAL_EXEC,
2568 coex_dm->ps_tdma_du_adj_type =
2570 } else if (coex_dm->cur_ps_tdma == 7) {
2571 halbtc8723b2ant_ps_tdma(
2572 btcoexist, NORMAL_EXEC,
2574 coex_dm->ps_tdma_du_adj_type =
2576 } else if (coex_dm->cur_ps_tdma == 13) {
2577 halbtc8723b2ant_ps_tdma(
2578 btcoexist, NORMAL_EXEC,
2580 coex_dm->ps_tdma_du_adj_type =
2582 } else if (coex_dm->cur_ps_tdma == 14) {
2583 halbtc8723b2ant_ps_tdma(
2584 btcoexist, NORMAL_EXEC,
2586 coex_dm->ps_tdma_du_adj_type =
2588 } else if (coex_dm->cur_ps_tdma == 15) {
2589 halbtc8723b2ant_ps_tdma(
2590 btcoexist, NORMAL_EXEC,
2592 coex_dm->ps_tdma_du_adj_type =
2595 } else if (result == 1) {
2596 if (coex_dm->cur_ps_tdma == 8) {
2597 halbtc8723b2ant_ps_tdma(
2598 btcoexist, NORMAL_EXEC,
2600 coex_dm->ps_tdma_du_adj_type =
2602 } else if (coex_dm->cur_ps_tdma == 7) {
2603 halbtc8723b2ant_ps_tdma(
2604 btcoexist, NORMAL_EXEC,
2606 coex_dm->ps_tdma_du_adj_type =
2608 } else if (coex_dm->cur_ps_tdma == 6) {
2609 halbtc8723b2ant_ps_tdma(
2610 btcoexist, NORMAL_EXEC,
2612 coex_dm->ps_tdma_du_adj_type =
2614 } else if (coex_dm->cur_ps_tdma == 16) {
2615 halbtc8723b2ant_ps_tdma(
2616 btcoexist, NORMAL_EXEC,
2618 coex_dm->ps_tdma_du_adj_type =
2620 } else if (coex_dm->cur_ps_tdma == 15) {
2621 halbtc8723b2ant_ps_tdma(
2622 btcoexist, NORMAL_EXEC,
2624 coex_dm->ps_tdma_du_adj_type =
2626 } else if (coex_dm->cur_ps_tdma == 14) {
2627 halbtc8723b2ant_ps_tdma(
2628 btcoexist, NORMAL_EXEC,
2630 coex_dm->ps_tdma_du_adj_type =
2635 if (coex_dm->cur_ps_tdma == 5) {
2636 halbtc8723b2ant_ps_tdma(btcoexist,
2637 NORMAL_EXEC, true, 2);
2638 coex_dm->ps_tdma_du_adj_type = 2;
2639 } else if (coex_dm->cur_ps_tdma == 6) {
2640 halbtc8723b2ant_ps_tdma(btcoexist,
2641 NORMAL_EXEC, true, 2);
2642 coex_dm->ps_tdma_du_adj_type = 2;
2643 } else if (coex_dm->cur_ps_tdma == 7) {
2644 halbtc8723b2ant_ps_tdma(btcoexist,
2645 NORMAL_EXEC, true, 3);
2646 coex_dm->ps_tdma_du_adj_type = 3;
2647 } else if (coex_dm->cur_ps_tdma == 8) {
2648 halbtc8723b2ant_ps_tdma(btcoexist,
2649 NORMAL_EXEC, true, 4);
2650 coex_dm->ps_tdma_du_adj_type = 4;
2652 if (coex_dm->cur_ps_tdma == 13) {
2653 halbtc8723b2ant_ps_tdma(btcoexist,
2654 NORMAL_EXEC, true, 10);
2655 coex_dm->ps_tdma_du_adj_type = 10;
2656 } else if (coex_dm->cur_ps_tdma == 14) {
2657 halbtc8723b2ant_ps_tdma(btcoexist,
2658 NORMAL_EXEC, true, 10);
2659 coex_dm->ps_tdma_du_adj_type = 10;
2660 } else if (coex_dm->cur_ps_tdma == 15) {
2661 halbtc8723b2ant_ps_tdma(btcoexist,
2662 NORMAL_EXEC, true, 11);
2663 coex_dm->ps_tdma_du_adj_type = 11;
2664 } else if (coex_dm->cur_ps_tdma == 16) {
2665 halbtc8723b2ant_ps_tdma(btcoexist,
2666 NORMAL_EXEC, true, 12);
2667 coex_dm->ps_tdma_du_adj_type = 12;
2670 if (coex_dm->cur_ps_tdma == 1) {
2671 halbtc8723b2ant_ps_tdma(
2672 btcoexist, NORMAL_EXEC,
2674 coex_dm->ps_tdma_du_adj_type =
2676 } else if (coex_dm->cur_ps_tdma == 2) {
2677 halbtc8723b2ant_ps_tdma(
2678 btcoexist, NORMAL_EXEC,
2680 coex_dm->ps_tdma_du_adj_type =
2682 } else if (coex_dm->cur_ps_tdma == 3) {
2683 halbtc8723b2ant_ps_tdma(
2684 btcoexist, NORMAL_EXEC,
2686 coex_dm->ps_tdma_du_adj_type =
2688 } else if (coex_dm->cur_ps_tdma == 9) {
2689 halbtc8723b2ant_ps_tdma(
2690 btcoexist, NORMAL_EXEC,
2692 coex_dm->ps_tdma_du_adj_type =
2694 } else if (coex_dm->cur_ps_tdma == 10) {
2695 halbtc8723b2ant_ps_tdma(
2696 btcoexist, NORMAL_EXEC,
2698 coex_dm->ps_tdma_du_adj_type =
2700 } else if (coex_dm->cur_ps_tdma == 11) {
2701 halbtc8723b2ant_ps_tdma(
2702 btcoexist, NORMAL_EXEC,
2704 coex_dm->ps_tdma_du_adj_type =
2707 } else if (result == 1) {
2708 if (coex_dm->cur_ps_tdma == 4) {
2709 halbtc8723b2ant_ps_tdma(
2710 btcoexist, NORMAL_EXEC,
2712 coex_dm->ps_tdma_du_adj_type =
2714 } else if (coex_dm->cur_ps_tdma == 3) {
2715 halbtc8723b2ant_ps_tdma(
2716 btcoexist, NORMAL_EXEC,
2718 coex_dm->ps_tdma_du_adj_type =
2720 } else if (coex_dm->cur_ps_tdma == 2) {
2721 halbtc8723b2ant_ps_tdma(
2722 btcoexist, NORMAL_EXEC,
2724 coex_dm->ps_tdma_du_adj_type =
2726 } else if (coex_dm->cur_ps_tdma == 12) {
2727 halbtc8723b2ant_ps_tdma(
2728 btcoexist, NORMAL_EXEC,
2730 coex_dm->ps_tdma_du_adj_type =
2732 } else if (coex_dm->cur_ps_tdma == 11) {
2733 halbtc8723b2ant_ps_tdma(
2734 btcoexist, NORMAL_EXEC,
2736 coex_dm->ps_tdma_du_adj_type =
2738 } else if (coex_dm->cur_ps_tdma == 10) {
2739 halbtc8723b2ant_ps_tdma(
2740 btcoexist, NORMAL_EXEC,
2742 coex_dm->ps_tdma_du_adj_type =
2747 } else if (max_interval == 3) {
2749 if (coex_dm->cur_ps_tdma == 1) {
2750 halbtc8723b2ant_ps_tdma(btcoexist,
2751 NORMAL_EXEC, true, 7);
2752 coex_dm->ps_tdma_du_adj_type = 7;
2753 } else if (coex_dm->cur_ps_tdma == 2) {
2754 halbtc8723b2ant_ps_tdma(btcoexist,
2755 NORMAL_EXEC, true, 7);
2756 coex_dm->ps_tdma_du_adj_type = 7;
2757 } else if (coex_dm->cur_ps_tdma == 3) {
2758 halbtc8723b2ant_ps_tdma(btcoexist,
2759 NORMAL_EXEC, true, 7);
2760 coex_dm->ps_tdma_du_adj_type = 7;
2761 } else if (coex_dm->cur_ps_tdma == 4) {
2762 halbtc8723b2ant_ps_tdma(btcoexist,
2763 NORMAL_EXEC, true, 8);
2764 coex_dm->ps_tdma_du_adj_type = 8;
2766 if (coex_dm->cur_ps_tdma == 9) {
2767 halbtc8723b2ant_ps_tdma(btcoexist,
2768 NORMAL_EXEC, true, 15);
2769 coex_dm->ps_tdma_du_adj_type = 15;
2770 } else if (coex_dm->cur_ps_tdma == 10) {
2771 halbtc8723b2ant_ps_tdma(btcoexist,
2772 NORMAL_EXEC, true, 15);
2773 coex_dm->ps_tdma_du_adj_type = 15;
2774 } else if (coex_dm->cur_ps_tdma == 11) {
2775 halbtc8723b2ant_ps_tdma(btcoexist,
2776 NORMAL_EXEC, true, 15);
2777 coex_dm->ps_tdma_du_adj_type = 15;
2778 } else if (coex_dm->cur_ps_tdma == 12) {
2779 halbtc8723b2ant_ps_tdma(btcoexist,
2780 NORMAL_EXEC, true, 16);
2781 coex_dm->ps_tdma_du_adj_type = 16;
2784 if (coex_dm->cur_ps_tdma == 5) {
2785 halbtc8723b2ant_ps_tdma(
2786 btcoexist, NORMAL_EXEC,
2788 coex_dm->ps_tdma_du_adj_type =
2790 } else if (coex_dm->cur_ps_tdma == 6) {
2791 halbtc8723b2ant_ps_tdma(
2792 btcoexist, NORMAL_EXEC,
2794 coex_dm->ps_tdma_du_adj_type =
2796 } else if (coex_dm->cur_ps_tdma == 7) {
2797 halbtc8723b2ant_ps_tdma(
2798 btcoexist, NORMAL_EXEC,
2800 coex_dm->ps_tdma_du_adj_type =
2802 } else if (coex_dm->cur_ps_tdma == 13) {
2803 halbtc8723b2ant_ps_tdma(
2804 btcoexist, NORMAL_EXEC,
2806 coex_dm->ps_tdma_du_adj_type =
2808 } else if (coex_dm->cur_ps_tdma == 14) {
2809 halbtc8723b2ant_ps_tdma(
2810 btcoexist, NORMAL_EXEC,
2812 coex_dm->ps_tdma_du_adj_type =
2814 } else if (coex_dm->cur_ps_tdma == 15) {
2815 halbtc8723b2ant_ps_tdma(
2816 btcoexist, NORMAL_EXEC,
2818 coex_dm->ps_tdma_du_adj_type =
2821 } else if (result == 1) {
2822 if (coex_dm->cur_ps_tdma == 8) {
2823 halbtc8723b2ant_ps_tdma(
2824 btcoexist, NORMAL_EXEC,
2826 coex_dm->ps_tdma_du_adj_type =
2828 } else if (coex_dm->cur_ps_tdma == 7) {
2829 halbtc8723b2ant_ps_tdma(
2830 btcoexist, NORMAL_EXEC,
2832 coex_dm->ps_tdma_du_adj_type =
2834 } else if (coex_dm->cur_ps_tdma == 6) {
2835 halbtc8723b2ant_ps_tdma(
2836 btcoexist, NORMAL_EXEC,
2838 coex_dm->ps_tdma_du_adj_type =
2840 } else if (coex_dm->cur_ps_tdma == 16) {
2841 halbtc8723b2ant_ps_tdma(
2842 btcoexist, NORMAL_EXEC,
2844 coex_dm->ps_tdma_du_adj_type =
2846 } else if (coex_dm->cur_ps_tdma == 15) {
2847 halbtc8723b2ant_ps_tdma(
2848 btcoexist, NORMAL_EXEC,
2850 coex_dm->ps_tdma_du_adj_type =
2852 } else if (coex_dm->cur_ps_tdma == 14) {
2853 halbtc8723b2ant_ps_tdma(
2854 btcoexist, NORMAL_EXEC,
2856 coex_dm->ps_tdma_du_adj_type =
2861 if (coex_dm->cur_ps_tdma == 5) {
2862 halbtc8723b2ant_ps_tdma(btcoexist,
2863 NORMAL_EXEC, true, 3);
2864 coex_dm->ps_tdma_du_adj_type = 3;
2865 } else if (coex_dm->cur_ps_tdma == 6) {
2866 halbtc8723b2ant_ps_tdma(btcoexist,
2867 NORMAL_EXEC, true, 3);
2868 coex_dm->ps_tdma_du_adj_type = 3;
2869 } else if (coex_dm->cur_ps_tdma == 7) {
2870 halbtc8723b2ant_ps_tdma(btcoexist,
2871 NORMAL_EXEC, true, 3);
2872 coex_dm->ps_tdma_du_adj_type = 3;
2873 } else if (coex_dm->cur_ps_tdma == 8) {
2874 halbtc8723b2ant_ps_tdma(btcoexist,
2875 NORMAL_EXEC, true, 4);
2876 coex_dm->ps_tdma_du_adj_type = 4;
2878 if (coex_dm->cur_ps_tdma == 13) {
2879 halbtc8723b2ant_ps_tdma(btcoexist,
2880 NORMAL_EXEC, true, 11);
2881 coex_dm->ps_tdma_du_adj_type = 11;
2882 } else if (coex_dm->cur_ps_tdma == 14) {
2883 halbtc8723b2ant_ps_tdma(btcoexist,
2884 NORMAL_EXEC, true, 11);
2885 coex_dm->ps_tdma_du_adj_type = 11;
2886 } else if (coex_dm->cur_ps_tdma == 15) {
2887 halbtc8723b2ant_ps_tdma(btcoexist,
2888 NORMAL_EXEC, true, 11);
2889 coex_dm->ps_tdma_du_adj_type = 11;
2890 } else if (coex_dm->cur_ps_tdma == 16) {
2891 halbtc8723b2ant_ps_tdma(btcoexist,
2892 NORMAL_EXEC, true, 12);
2893 coex_dm->ps_tdma_du_adj_type = 12;
2896 if (coex_dm->cur_ps_tdma == 1) {
2897 halbtc8723b2ant_ps_tdma(
2898 btcoexist, NORMAL_EXEC,
2900 coex_dm->ps_tdma_du_adj_type =
2902 } else if (coex_dm->cur_ps_tdma == 2) {
2903 halbtc8723b2ant_ps_tdma(
2904 btcoexist, NORMAL_EXEC,
2906 coex_dm->ps_tdma_du_adj_type =
2908 } else if (coex_dm->cur_ps_tdma == 3) {
2909 halbtc8723b2ant_ps_tdma(
2910 btcoexist, NORMAL_EXEC,
2912 coex_dm->ps_tdma_du_adj_type =
2914 } else if (coex_dm->cur_ps_tdma == 9) {
2915 halbtc8723b2ant_ps_tdma(
2916 btcoexist, NORMAL_EXEC,
2918 coex_dm->ps_tdma_du_adj_type =
2920 } else if (coex_dm->cur_ps_tdma == 10) {
2921 halbtc8723b2ant_ps_tdma(
2922 btcoexist, NORMAL_EXEC,
2924 coex_dm->ps_tdma_du_adj_type =
2926 } else if (coex_dm->cur_ps_tdma == 11) {
2927 halbtc8723b2ant_ps_tdma(
2928 btcoexist, NORMAL_EXEC,
2930 coex_dm->ps_tdma_du_adj_type =
2933 } else if (result == 1) {
2934 if (coex_dm->cur_ps_tdma == 4) {
2935 halbtc8723b2ant_ps_tdma(
2936 btcoexist, NORMAL_EXEC,
2938 coex_dm->ps_tdma_du_adj_type =
2940 } else if (coex_dm->cur_ps_tdma == 3) {
2941 halbtc8723b2ant_ps_tdma(
2942 btcoexist, NORMAL_EXEC,
2944 coex_dm->ps_tdma_du_adj_type =
2946 } else if (coex_dm->cur_ps_tdma == 2) {
2947 halbtc8723b2ant_ps_tdma(
2948 btcoexist, NORMAL_EXEC,
2950 coex_dm->ps_tdma_du_adj_type =
2952 } else if (coex_dm->cur_ps_tdma == 12) {
2953 halbtc8723b2ant_ps_tdma(
2954 btcoexist, NORMAL_EXEC,
2956 coex_dm->ps_tdma_du_adj_type =
2958 } else if (coex_dm->cur_ps_tdma == 11) {
2959 halbtc8723b2ant_ps_tdma(
2960 btcoexist, NORMAL_EXEC,
2962 coex_dm->ps_tdma_du_adj_type =
2964 } else if (coex_dm->cur_ps_tdma == 10) {
2965 halbtc8723b2ant_ps_tdma(
2966 btcoexist, NORMAL_EXEC,
2968 coex_dm->ps_tdma_du_adj_type =
2976 /* if current PsTdma not match with the recorded one (when scan, dhcp...), */
2977 /* then we have to adjust it back to the previous record one. */
2978 if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2979 boolean scan = false, link = false, roam = false;
2981 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2982 "[BTCoex], PsTdma type dismatch!!!, cur_ps_tdma=%d, recordPsTdma=%d\n",
2983 coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2984 BTC_TRACE(trace_buf);
2986 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2987 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2988 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2990 if (!scan && !link && !roam)
2991 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2992 coex_dm->ps_tdma_du_adj_type);
2994 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2995 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2996 BTC_TRACE(trace_buf);
3001 /* SCO only or SCO+PAN(HS) */
3002 void halbtc8723b2ant_action_sco(IN struct btc_coexist *btcoexist)
3004 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3005 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3006 u8 wifi_rssi_state, bt_rssi_state;
3009 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3010 &prewifi_rssi_state, 2, 15, 0);
3011 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3012 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3013 coex_dm->switch_thres_offset, 0);
3015 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3017 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3019 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
3021 if (BTC_RSSI_HIGH(bt_rssi_state))
3022 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3024 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3026 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3028 if (BTC_WIFI_BW_LEGACY == wifi_bw) /* for SCO quality at 11b/g mode */
3029 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
3030 else /* for SCO quality & wifi performance balance at 11n mode */
3031 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3033 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
3034 0); /* for voice quality */
3037 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3038 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3039 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3040 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3042 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3045 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3047 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3051 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3052 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3053 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3055 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3058 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3060 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3067 void halbtc8723b2ant_action_hid(IN struct btc_coexist *btcoexist)
3069 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3070 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3071 u8 wifi_rssi_state, bt_rssi_state;
3074 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 25);
3076 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3077 &prewifi_rssi_state, 2, 15, 0);
3078 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3079 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3080 coex_dm->switch_thres_offset, 0);
3082 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3084 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3086 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3088 if (BTC_RSSI_HIGH(bt_rssi_state))
3089 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3091 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3093 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3095 if (BTC_WIFI_BW_LEGACY == wifi_bw) /* for HID at 11b/g mode */
3096 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3097 else /* for HID quality & wifi performance balance at 11n mode */
3098 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 9);
3100 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3101 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
3102 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
3104 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
3107 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3108 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3109 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3110 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3112 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3115 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3117 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3121 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3122 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3123 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3125 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3128 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3130 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3136 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
3137 void halbtc8723b2ant_action_a2dp(IN struct btc_coexist *btcoexist)
3139 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3140 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3141 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3142 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3146 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3147 &prewifi_rssi_state, 2, 15, 0);
3148 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3149 &prewifi_rssi_state1, 2,
3150 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3151 coex_dm->switch_thres_offset, 0);
3152 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3153 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3154 coex_dm->switch_thres_offset, 0);
3156 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3158 /* define the office environment */
3159 if ((ap_num >= 10) && BTC_RSSI_HIGH(wifi_rssi_state1) &&
3160 BTC_RSSI_HIGH(bt_rssi_state)) {
3161 /* dbg_print(" AP#>10(%d)\n", ap_num); */
3163 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
3165 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
3167 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3168 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3170 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3172 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3175 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3176 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3177 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3179 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3182 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3184 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3191 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3192 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3194 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3196 if (BTC_RSSI_HIGH(bt_rssi_state))
3197 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3199 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3202 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3203 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3206 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3211 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3212 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
3213 halbtc8723b2ant_tdma_duration_adjust(btcoexist, false, false,
3216 halbtc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
3219 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3220 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3221 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3222 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3223 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3225 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3228 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3230 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3234 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3235 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3236 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3238 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3241 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3243 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3249 void halbtc8723b2ant_action_a2dp_pan_hs(IN struct btc_coexist *btcoexist)
3251 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3252 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3253 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3254 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3257 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3258 &prewifi_rssi_state, 2, 15, 0);
3259 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3260 &prewifi_rssi_state1, 2,
3261 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3262 coex_dm->switch_thres_offset, 0);
3263 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3264 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3265 coex_dm->switch_thres_offset, 0);
3267 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3269 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3271 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3273 if (BTC_RSSI_HIGH(bt_rssi_state))
3274 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3276 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3278 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3279 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3282 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3286 halbtc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
3289 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3290 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3291 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3292 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3293 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3295 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3298 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3300 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3304 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3305 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3306 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3308 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3311 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3313 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3319 void halbtc8723b2ant_action_pan_edr(IN struct btc_coexist *btcoexist)
3321 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3322 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3323 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3324 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3327 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3328 &prewifi_rssi_state, 2, 15, 0);
3329 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3330 &prewifi_rssi_state1, 2,
3331 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3332 coex_dm->switch_thres_offset, 0);
3333 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3334 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3335 coex_dm->switch_thres_offset, 0);
3337 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3339 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3341 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3343 if (BTC_RSSI_HIGH(bt_rssi_state))
3344 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3346 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3348 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3349 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3352 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3356 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3357 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
3358 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
3360 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
3363 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3364 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3365 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3366 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3367 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3369 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3372 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3374 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3378 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3379 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3380 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3382 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3385 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3387 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3395 void halbtc8723b2ant_action_pan_hs(IN struct btc_coexist *btcoexist)
3397 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3398 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3399 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3400 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3403 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3404 &prewifi_rssi_state, 2, 15, 0);
3405 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3406 &prewifi_rssi_state1, 2,
3407 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3408 coex_dm->switch_thres_offset, 0);
3409 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3410 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3411 coex_dm->switch_thres_offset, 0);
3413 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3415 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3417 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3419 if (BTC_RSSI_HIGH(bt_rssi_state))
3420 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3422 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3424 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3426 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3428 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3429 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3430 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3431 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3432 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3434 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3437 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3439 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3443 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3444 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3445 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3447 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3450 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3452 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3459 void halbtc8723b2ant_action_pan_edr_a2dp(IN struct btc_coexist *btcoexist)
3461 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3462 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3463 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3464 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3468 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3469 &prewifi_rssi_state, 2, 15, 0);
3470 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3471 &prewifi_rssi_state1, 2,
3472 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3473 coex_dm->switch_thres_offset, 0);
3474 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3475 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3476 coex_dm->switch_thres_offset, 0);
3478 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3480 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3482 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3484 if (BTC_RSSI_HIGH(bt_rssi_state))
3485 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3487 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3489 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3490 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3493 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3494 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3495 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3499 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3502 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3506 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3509 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3512 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3517 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3518 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3519 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3520 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3522 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3525 halbtc8723b2ant_sw_mechanism1(btcoexist, true, false,
3527 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3531 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3532 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3533 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3535 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3538 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false,
3540 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3546 void halbtc8723b2ant_action_pan_edr_hid(IN struct btc_coexist *btcoexist)
3548 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3549 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3550 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3551 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3554 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 25);
3556 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3557 &prewifi_rssi_state, 2, 15, 0);
3558 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3559 &prewifi_rssi_state1, 2,
3560 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3561 coex_dm->switch_thres_offset, 0);
3562 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3563 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3564 coex_dm->switch_thres_offset, 0);
3565 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3567 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3569 if (BTC_RSSI_HIGH(bt_rssi_state))
3570 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3572 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3574 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3575 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3577 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3581 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3582 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3583 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3584 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3586 /* halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 11); */
3587 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3590 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3592 /* halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7); */
3593 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3596 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
3598 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3599 /* halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14); */
3600 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
3602 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
3606 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3607 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3608 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3609 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3611 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3614 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3616 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3620 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3621 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3622 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3624 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3627 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3629 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3635 /* HID+A2DP+PAN(EDR) */
3636 void halbtc8723b2ant_action_hid_a2dp_pan_edr(IN struct btc_coexist *btcoexist)
3638 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3639 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3640 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3641 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3644 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 25);
3646 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3647 &prewifi_rssi_state, 2, 15, 0);
3648 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3649 &prewifi_rssi_state1, 2,
3650 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3651 coex_dm->switch_thres_offset, 0);
3652 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3653 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3654 coex_dm->switch_thres_offset, 0);
3656 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3658 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3660 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3662 if (BTC_RSSI_HIGH(bt_rssi_state))
3663 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3665 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3667 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3668 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3670 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3674 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3676 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3677 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3678 if (BTC_WIFI_BW_HT40 == wifi_bw)
3679 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3682 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3685 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3688 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3689 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3690 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3691 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3693 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3696 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3698 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3702 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3703 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3704 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3706 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3709 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3711 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3717 void halbtc8723b2ant_action_hid_a2dp(IN struct btc_coexist *btcoexist)
3719 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW,
3720 prewifi_rssi_state1 = BTC_RSSI_STATE_LOW;
3721 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3722 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3726 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 35);
3729 wifi_rssi_state = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3730 &prewifi_rssi_state, 2, 15, 0);
3731 /* bt_rssi_state = halbtc8723b2ant_bt_rssi_state(2, 29, 0); */
3732 wifi_rssi_state1 = halbtc8723b2ant_wifi_rssi_state(btcoexist,
3733 &prewifi_rssi_state1, 2,
3734 BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3735 coex_dm->switch_thres_offset, 0);
3736 bt_rssi_state = halbtc8723b2ant_bt_rssi_state(&pre_bt_rssi_state, 3,
3737 BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3738 coex_dm->switch_thres_offset, 37);
3740 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3743 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3745 halbtc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3747 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3749 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3750 if (BTC_WIFI_BW_LEGACY == wifi_bw) {
3751 if (BTC_RSSI_HIGH(bt_rssi_state))
3752 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3753 else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3754 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3756 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3758 /* only 802.11N mode we have to dec bt power to 4 degree */
3759 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3760 /* need to check ap Number of Not */
3762 halbtc8723b2ant_dec_bt_pwr(btcoexist,
3765 halbtc8723b2ant_dec_bt_pwr(btcoexist,
3767 } else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3768 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3770 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3773 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3774 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3776 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3780 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3782 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3786 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3789 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 18);
3790 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
3791 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
3792 btcoexist->btc_write_4byte(btcoexist, 0x430, 0x0);
3793 btcoexist->btc_write_4byte(btcoexist, 0x434, 0x01010000);
3796 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3800 halbtc8723b2ant_tdma_duration_adjust(btcoexist, true,
3805 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3806 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3807 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3808 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3810 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3813 halbtc8723b2ant_sw_mechanism1(btcoexist, true, true,
3815 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3819 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3820 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3821 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3823 halbtc8723b2ant_sw_mechanism2(btcoexist, true, false,
3826 halbtc8723b2ant_sw_mechanism1(btcoexist, false, true,
3828 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false,
3834 void halbtc8723b2ant_action_bt_whck_test(IN struct btc_coexist *btcoexist)
3836 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3839 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
3840 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
3842 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3843 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3846 void halbtc8723b2ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
3848 halbtc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3849 halbtc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3852 halbtc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
3853 halbtc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
3856 /* btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
3857 halbtc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3859 halbtc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3862 void halbtc8723b2ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
3865 u32 num_of_wifi_link = 0;
3866 u32 wifi_link_status = 0;
3867 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3868 boolean miracast_plus_bt = false;
3869 boolean scan = false, link = false, roam = false;
3871 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3872 "[BTCoex], RunCoexistMechanism()===>\n");
3873 BTC_TRACE(trace_buf);
3875 if (btcoexist->manual_control) {
3876 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3877 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3878 BTC_TRACE(trace_buf);
3882 if (coex_sta->under_ips) {
3883 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3884 "[BTCoex], wifi is under IPS !!!\n");
3885 BTC_TRACE(trace_buf);
3889 if (coex_sta->bt_whck_test) {
3890 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3891 "[BTCoex], BT is under WHCK TEST!!!\n");
3892 BTC_TRACE(trace_buf);
3893 halbtc8723b2ant_action_bt_whck_test(btcoexist);
3897 algorithm = halbtc8723b2ant_action_algorithm(btcoexist);
3898 if (coex_sta->c2h_bt_inquiry_page &&
3899 (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
3900 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3901 "[BTCoex], BT is under inquiry/page scan !!\n");
3902 BTC_TRACE(trace_buf);
3903 halbtc8723b2ant_action_bt_inquiry(btcoexist);
3908 if(coex_dm->need_recover0x948)
3910 coex_dm->need_recover0x948 = false;
3911 btcoexist->btc_write_4byte(btcoexist, 0x948, coex_dm->backup0x948);
3915 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3916 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3917 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3919 if (scan || link || roam) {
3920 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3921 "[BTCoex], WiFi is under Link Process !!\n");
3922 BTC_TRACE(trace_buf);
3923 halbtc8723b2ant_action_wifi_link_process(btcoexist);
3929 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3931 num_of_wifi_link = wifi_link_status >> 16;
3933 if ((num_of_wifi_link >= 2) ||
3934 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3935 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3936 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3937 num_of_wifi_link, wifi_link_status);
3938 BTC_TRACE(trace_buf);
3940 if (bt_link_info->bt_link_exist)
3941 miracast_plus_bt = true;
3943 miracast_plus_bt = false;
3945 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3947 halbtc8723b2ant_action_wifi_multi_port(btcoexist);
3952 miracast_plus_bt = false;
3953 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3956 coex_dm->cur_algorithm = algorithm;
3957 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Algorithm = %d\n",
3958 coex_dm->cur_algorithm);
3959 BTC_TRACE(trace_buf);
3961 if (halbtc8723b2ant_is_common_action(btcoexist)) {
3962 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3963 "[BTCoex], Action 2-Ant common.\n");
3964 BTC_TRACE(trace_buf);
3965 coex_dm->auto_tdma_adjust = false;
3967 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3968 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3969 "[BTCoex], pre_algorithm=%d, cur_algorithm=%d\n",
3970 coex_dm->pre_algorithm, coex_dm->cur_algorithm);
3971 BTC_TRACE(trace_buf);
3972 coex_dm->auto_tdma_adjust = false;
3974 switch (coex_dm->cur_algorithm) {
3975 case BT_8723B_2ANT_COEX_ALGO_SCO:
3976 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3977 "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
3978 BTC_TRACE(trace_buf);
3979 halbtc8723b2ant_action_sco(btcoexist);
3981 case BT_8723B_2ANT_COEX_ALGO_HID:
3982 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3983 "[BTCoex], Action 2-Ant, algorithm = HID.\n");
3984 BTC_TRACE(trace_buf);
3985 halbtc8723b2ant_action_hid(btcoexist);
3987 case BT_8723B_2ANT_COEX_ALGO_A2DP:
3988 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3989 "[BTCoex], Action 2-Ant, algorithm = A2DP.\n");
3990 BTC_TRACE(trace_buf);
3991 halbtc8723b2ant_action_a2dp(btcoexist);
3993 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
3994 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3995 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
3996 BTC_TRACE(trace_buf);
3997 halbtc8723b2ant_action_a2dp_pan_hs(btcoexist);
3999 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
4000 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4001 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n");
4002 BTC_TRACE(trace_buf);
4003 halbtc8723b2ant_action_pan_edr(btcoexist);
4005 case BT_8723B_2ANT_COEX_ALGO_PANHS:
4006 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4007 "[BTCoex], Action 2-Ant, algorithm = HS mode.\n");
4008 BTC_TRACE(trace_buf);
4009 halbtc8723b2ant_action_pan_hs(btcoexist);
4011 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
4012 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4013 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n");
4014 BTC_TRACE(trace_buf);
4015 halbtc8723b2ant_action_pan_edr_a2dp(btcoexist);
4017 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
4018 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4019 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
4020 BTC_TRACE(trace_buf);
4021 halbtc8723b2ant_action_pan_edr_hid(btcoexist);
4023 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
4024 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4025 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
4026 BTC_TRACE(trace_buf);
4027 halbtc8723b2ant_action_hid_a2dp_pan_edr(
4030 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
4031 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4032 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n");
4033 BTC_TRACE(trace_buf);
4034 halbtc8723b2ant_action_hid_a2dp(btcoexist);
4037 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4038 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
4039 BTC_TRACE(trace_buf);
4040 halbtc8723b2ant_coex_all_off(btcoexist);
4043 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
4047 void halbtc8723b2ant_wifi_off_hw_cfg(IN struct btc_coexist *btcoexist)
4049 boolean is_in_mp_mode = false;
4050 u8 h2c_parameter[2] = {0};
4053 /* set wlan_act to low */
4054 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
4056 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
4057 0x780); /* WiFi goto standby while GNT_BT 0-->1 */
4058 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
4059 if (fw_ver >= 0x180000) {
4060 /* Use H2C to set GNT_BT to HIGH */
4061 h2c_parameter[0] = 1;
4062 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
4064 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
4066 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
4069 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20,
4070 0x0); /* BT select s0/s1 is controlled by BT */
4072 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20,
4073 0x1); /* BT select s0/s1 is controlled by WiFi */
4076 void halbtc8723b2ant_init_hw_config(IN struct btc_coexist *btcoexist,
4083 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4084 "[BTCoex], 2Ant Init HW Config!!\n");
4085 BTC_TRACE(trace_buf);
4086 btcoexist->btc_get(btcoexist, BTC_GET_U4_VENDOR, &vendor);
4087 if (vendor == BTC_VENDOR_LENOVO)
4088 coex_dm->switch_thres_offset = 0;
4089 else if (vendor == BTC_VENDOR_ASUS)
4090 coex_dm->switch_thres_offset = 0;
4092 coex_dm->switch_thres_offset = 20;
4094 /* 0xf0[15:12] --> Chip Cut information */
4095 coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
4098 /* backup rf 0x1e value */
4099 coex_dm->bt_rf_0x1e_backup =
4100 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
4102 /* 0x790[5:0]=0x5 */
4103 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
4106 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
4108 /* Antenna config */
4109 halbtc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN, true,
4111 coex_sta->dis_ver_info_cnt = 0;
4114 halbtc8723b2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
4116 /* Enable counter statistics */
4117 btcoexist->btc_write_1byte(btcoexist, 0x76e,
4118 0x4); /* 0x76e[3] =1, WLAN_Act control by PTA */
4119 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
4120 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
4122 /* Give bt_coex_supported_version the default value */
4123 coex_sta->bt_coex_supported_version = 0;
4127 /* ************************************************************
4128 * work around function start with wa_halbtc8723b2ant_
4129 * ************************************************************
4130 * ************************************************************
4131 * extern function start with ex_halbtc8723b2ant_
4132 * ************************************************************ */
4133 void ex_halbtc8723b2ant_power_on_setting(IN struct btc_coexist *btcoexist)
4135 struct btc_board_info *board_info = &btcoexist->board_info;
4140 btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
4142 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
4143 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
4144 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
4146 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
4148 if (btcoexist->chip_interface == BTC_INTF_USB) {
4149 /* fixed at S0 for USB interface */
4150 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
4152 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
4153 if (board_info->single_ant_path == 0) {
4155 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
4156 } else if (board_info->single_ant_path == 1) {
4158 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
4160 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
4165 void ex_halbtc8723b2ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
4167 struct btc_board_info *board_info = &btcoexist->board_info;
4168 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
4171 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
4172 /* Local setting bit define */
4173 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
4174 /* BIT1: "0" for internal switch; "1" for external switch */
4175 /* BIT2: "0" for one antenna; "1" for two antenna */
4176 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
4177 if (btcoexist->chip_interface == BTC_INTF_USB) {
4178 /* fixed at S0 for USB interface */
4179 u8tmp |= 0x1; /* antenna inverse */
4180 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
4182 if (board_info->single_ant_path == 1) {
4184 u8tmp |= 0x1; /* antenna inverse */
4187 if (btcoexist->chip_interface == BTC_INTF_PCI)
4188 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
4190 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
4191 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
4196 void ex_halbtc8723b2ant_init_hw_config(IN struct btc_coexist *btcoexist,
4197 IN boolean wifi_only)
4199 halbtc8723b2ant_init_hw_config(btcoexist, true);
4202 void ex_halbtc8723b2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
4204 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4205 "[BTCoex], Coex Mechanism Init!!\n");
4206 BTC_TRACE(trace_buf);
4208 halbtc8723b2ant_init_coex_dm(btcoexist);
4211 void ex_halbtc8723b2ant_display_coex_info(IN struct btc_coexist *btcoexist)
4213 struct btc_board_info *board_info = &btcoexist->board_info;
4214 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
4215 u8 *cli_buf = btcoexist->cli_buf;
4216 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
4218 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck;
4219 u32 fw_ver = 0, bt_patch_ver = 0;
4220 u32 bt_coex_ver = 0;
4221 static u8 pop_report_in_10s = 0;
4224 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4225 "\r\n ============[BT Coexist info]============");
4228 if (btcoexist->manual_control) {
4229 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4230 "\r\n ============[Under Manual Control]============");
4232 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4233 "\r\n ==========================================");
4237 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d ",
4238 "Ant PG number/ Ant mechanism:",
4239 board_info->pg_ant_num, board_info->btdm_ant_num);
4242 /* btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver); */
4243 bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
4244 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
4245 phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
4246 bt_coex_ver = coex_sta->bt_coex_supported_version & 0xff;
4248 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4249 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
4250 "CoexVer WL/ BT_Desired/ BT_Report",
4251 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
4252 glcoex_ver_btdesired_8723b_2ant,
4254 (bt_coex_ver == 0xff ? "Unknown" :
4255 (bt_coex_ver >= glcoex_ver_btdesired_8723b_2ant ?
4256 "Match" : "Mis-Match")));
4259 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4260 "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
4261 "W_FW/ B_FW/ Phy/ Kt",
4262 fw_ver, bt_patch_ver, phyver,
4263 coex_sta->cut_version + 65);
4266 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
4267 "Wifi channel informed to BT",
4268 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
4269 coex_dm->wifi_chnl_info[2]);
4273 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4274 "============[Wifi Status]============");
4276 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
4278 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4279 "============[BT Status]============");
4282 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4284 (coex_sta->bt_abnormal_scan) ? "Yes" : "No");
4287 pop_report_in_10s++;
4288 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = [%s/ %d/ %d/ %d] ",
4289 "BT [status/ rssi/ retryCnt/ popCnt]",
4290 ((coex_sta->bt_disabled) ? ("disabled") : ((
4291 coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan")
4292 : ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
4293 coex_dm->bt_status) ? "non-connected idle" :
4294 ((BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
4295 ? "connected-idle" : "busy")))),
4296 coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
4297 coex_sta->pop_event_cnt);
4300 if (pop_report_in_10s >= 5) {
4301 coex_sta->pop_event_cnt = 0;
4302 pop_report_in_10s = 0;
4306 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4307 "\r\n %-35s = %d / %d / %d / %d / %d / %d",
4308 "SCO/HID/PAN/A2DP/NameReq/WHQL",
4309 bt_link_info->sco_exist, bt_link_info->hid_exist,
4310 bt_link_info->pan_exist, bt_link_info->a2dp_exist,
4311 coex_sta->c2h_bt_remote_name_req,
4312 coex_sta->bt_whck_test);
4316 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4318 (bt_link_info->slave_role) ? "Slave" : "Master");
4322 bt_info_ext = coex_sta->bt_info_ext;
4323 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %d",
4324 "A2DP Rate/Bitpool",
4325 (bt_info_ext & BIT(0)) ? "BR" : "EDR", coex_sta->a2dp_bit_pool);
4328 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
4329 if (coex_sta->bt_info_c2h_cnt[i]) {
4330 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4331 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)",
4332 glbt_info_src_8723b_2ant[i],
4333 coex_sta->bt_info_c2h[i][0],
4334 coex_sta->bt_info_c2h[i][1],
4335 coex_sta->bt_info_c2h[i][2],
4336 coex_sta->bt_info_c2h[i][3],
4337 coex_sta->bt_info_c2h[i][4],
4338 coex_sta->bt_info_c2h[i][5],
4339 coex_sta->bt_info_c2h[i][6],
4340 coex_sta->bt_info_c2h_cnt[i]);
4346 if (btcoexist->manual_control)
4347 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4348 "============[Sw mechanism] (before Manual)============");
4350 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4351 "============[Sw mechanism]============");
4353 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d ",
4354 "SM1[ShRf/ LpRA/ LimDig]",
4355 coex_dm->cur_rf_rx_lpf_shrink, coex_dm->cur_low_penalty_ra,
4356 coex_dm->limited_dig);
4358 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
4359 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
4360 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
4361 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
4365 if (btcoexist->manual_control)
4366 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4367 "============[Fw mechanism] (before Manual) ============");
4369 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4370 "============[Fw mechanism]============");
4372 ps_tdma_case = coex_dm->cur_ps_tdma;
4374 if (coex_dm->is_switch_to_1dot5_ant)
4375 ps_tdma_case = ps_tdma_case + 100;
4377 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4378 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (%s,%s)",
4380 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
4381 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
4382 coex_dm->ps_tdma_para[4], ps_tdma_case,
4383 (coex_dm->cur_ps_tdma_on ? "On" : "Off"),
4384 (coex_dm->auto_tdma_adjust ? "Adj" : "Fix"));
4387 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4389 coex_sta->coex_table_type);
4392 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d ",
4393 "DecBtPwr/ IgnWlanAct",
4394 coex_dm->cur_bt_dec_pwr_lvl, coex_dm->cur_ignore_wlan_act);
4398 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4399 "============[Hw setting]============");
4402 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x",
4403 "RF-A, 0x1e initVal",
4404 coex_dm->bt_rf_0x1e_backup);
4407 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
4408 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
4409 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
4410 "0x778/0x880[29:25]",
4411 u8tmp[0], (u32tmp[0] & 0x3e000000) >> 25);
4415 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
4416 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
4417 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
4418 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
4419 "0x948/ 0x67[5] / 0x765",
4420 u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]);
4423 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
4424 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
4425 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
4426 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
4427 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
4428 u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
4432 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
4433 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
4434 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
4435 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
4436 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4437 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4438 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
4439 ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
4440 ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
4443 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
4444 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
4445 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
4446 "0x550(bcn ctrl)/0x522",
4447 u32tmp[0], u8tmp[0]);
4450 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
4451 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
4452 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
4453 "0xc50(dig)/0x49c(null-drop)",
4454 u32tmp[0] & 0xff, u8tmp[0]);
4457 fa_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4458 PHYDM_INFO_FA_OFDM);
4459 fa_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4461 cca_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4462 PHYDM_INFO_CCA_OFDM);
4463 cca_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4464 PHYDM_INFO_CCA_CCK);
4466 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4467 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4468 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA",
4469 cca_cck, fa_cck, cca_ofdm, fa_ofdm);
4472 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4473 "CRC_OK CCK/11g/11n/11n-agg",
4474 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
4475 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht);
4478 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4479 "CRC_Err CCK/11g/11n/11n-agg",
4480 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
4481 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
4484 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
4485 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
4486 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
4487 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
4488 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4489 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4490 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
4491 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
4494 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4495 "0x770(high-pri rx/tx)",
4496 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
4498 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4499 "0x774(low-pri rx/tx)",
4500 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
4502 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1)
4503 /* halbtc8723b2ant_monitor_bt_ctr(btcoexist); */
4505 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
4509 void ex_halbtc8723b2ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
4511 if (BTC_IPS_ENTER == type) {
4512 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4513 "[BTCoex], IPS ENTER notify\n");
4514 BTC_TRACE(trace_buf);
4515 coex_sta->under_ips = true;
4516 halbtc8723b2ant_wifi_off_hw_cfg(btcoexist);
4517 halbtc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4518 halbtc8723b2ant_coex_all_off(btcoexist);
4519 } else if (BTC_IPS_LEAVE == type) {
4520 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4521 "[BTCoex], IPS LEAVE notify\n");
4522 BTC_TRACE(trace_buf);
4523 coex_sta->under_ips = false;
4524 halbtc8723b2ant_init_hw_config(btcoexist, false);
4525 halbtc8723b2ant_init_coex_dm(btcoexist);
4526 halbtc8723b2ant_query_bt_info(btcoexist);
4530 void ex_halbtc8723b2ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
4532 if (BTC_LPS_ENABLE == type) {
4533 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4534 "[BTCoex], LPS ENABLE notify\n");
4535 BTC_TRACE(trace_buf);
4536 coex_sta->under_lps = true;
4537 } else if (BTC_LPS_DISABLE == type) {
4538 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4539 "[BTCoex], LPS DISABLE notify\n");
4540 BTC_TRACE(trace_buf);
4541 coex_sta->under_lps = false;
4545 void ex_halbtc8723b2ant_scan_notify(IN struct btc_coexist *btcoexist,
4553 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
4554 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
4555 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
4557 if (BTC_SCAN_START == type) {
4558 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4559 "[BTCoex], SCAN START notify\n");
4560 BTC_TRACE(trace_buf);
4561 halbtc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
4563 } else if (BTC_SCAN_FINISH == type) {
4564 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4565 "[BTCoex], SCAN FINISH notify\n");
4566 BTC_TRACE(trace_buf);
4567 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4568 &coex_sta->scan_ap_num);
4571 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4572 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x76e=0x%x\n",
4573 u32tmp, u8tmpa, u8tmpb);
4574 BTC_TRACE(trace_buf);
4577 void ex_halbtc8723b2ant_connect_notify(IN struct btc_coexist *btcoexist,
4580 if (BTC_ASSOCIATE_START == type) {
4581 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4582 "[BTCoex], CONNECT START notify\n");
4583 BTC_TRACE(trace_buf);
4584 halbtc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
4586 } else if (BTC_ASSOCIATE_FINISH == type) {
4587 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4588 "[BTCoex], CONNECT FINISH notify\n");
4589 BTC_TRACE(trace_buf);
4593 void ex_halbtc8723b2ant_media_status_notify(IN struct btc_coexist *btcoexist,
4596 u8 h2c_parameter[3] = {0};
4598 u8 wifi_central_chnl;
4601 if (BTC_MEDIA_CONNECT == type) {
4602 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4603 "[BTCoex], MEDIA connect notify\n");
4604 BTC_TRACE(trace_buf);
4605 halbtc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
4608 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4609 "[BTCoex], MEDIA disconnect notify\n");
4610 BTC_TRACE(trace_buf);
4613 /* only 2.4G we need to inform bt the chnl mask */
4614 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
4615 &wifi_central_chnl);
4616 if ((BTC_MEDIA_CONNECT == type) &&
4617 (wifi_central_chnl <= 14)) {
4618 h2c_parameter[0] = 0x1;
4619 h2c_parameter[1] = wifi_central_chnl;
4620 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
4621 if (BTC_WIFI_BW_HT40 == wifi_bw)
4622 h2c_parameter[2] = 0x30;
4624 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4627 h2c_parameter[2] = 0x30;
4629 h2c_parameter[2] = 0x20;
4633 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
4634 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
4635 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
4637 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
4640 void ex_halbtc8723b2ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
4643 if (type == BTC_PACKET_DHCP) {
4644 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4645 "[BTCoex], DHCP Packet notify\n");
4646 BTC_TRACE(trace_buf);
4650 void ex_halbtc8723b2ant_bt_info_notify(IN struct btc_coexist *btcoexist,
4651 IN u8 *tmp_buf, IN u8 length)
4654 u8 i, rsp_source = 0;
4655 boolean bt_busy = false, limited_dig = false;
4656 boolean wifi_connected = false;
4658 coex_sta->c2h_bt_info_req_sent = false;
4660 rsp_source = tmp_buf[0] & 0xf;
4661 if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
4662 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
4663 coex_sta->bt_info_c2h_cnt[rsp_source]++;
4665 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4666 "[BTCoex], Bt info[%d], length=%d, hex data=[", rsp_source,
4668 BTC_TRACE(trace_buf);
4669 for (i = 0; i < length; i++) {
4670 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
4672 bt_info = tmp_buf[i];
4673 if (i == length - 1) {
4674 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
4676 BTC_TRACE(trace_buf);
4678 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
4680 BTC_TRACE(trace_buf);
4684 if (btcoexist->manual_control) {
4685 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4686 "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
4687 BTC_TRACE(trace_buf);
4691 /* if 0xff, it means BT is under WHCK test */
4692 if (bt_info == 0xff)
4693 coex_sta->bt_whck_test = true;
4695 coex_sta->bt_whck_test = false;
4697 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
4698 coex_sta->bt_retry_cnt = /* [3:0] */
4699 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
4701 if (coex_sta->bt_retry_cnt >= 1)
4702 coex_sta->pop_event_cnt++;
4705 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4707 coex_sta->bt_info_ext =
4708 coex_sta->bt_info_c2h[rsp_source][4];
4710 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
4711 coex_sta->c2h_bt_remote_name_req = true;
4713 coex_sta->c2h_bt_remote_name_req = false;
4715 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49) {
4716 coex_sta->a2dp_bit_pool =
4717 coex_sta->bt_info_c2h[rsp_source][6];
4719 coex_sta->a2dp_bit_pool = 0;
4721 coex_sta->bt_tx_rx_mask = (coex_sta->bt_info_c2h[rsp_source][2]
4723 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
4724 &coex_sta->bt_tx_rx_mask);
4725 if (coex_sta->bt_tx_rx_mask) {
4726 /* BT into is responded by BT FW and BT RF REG 0x3C != 0x01 => Need to switch BT TRx Mask */
4727 /* BT TRx mask off */
4728 btcoexist->btc_set_bt_trx_mask(btcoexist, 0);
4730 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4731 "############# [BTCoex], BT TRx Mask off for BT Info Notify\n");
4732 BTC_TRACE(trace_buf);
4734 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4735 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n");
4736 BTC_TRACE(trace_buf);
4737 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
4742 /* Here we need to resend some wifi info to BT */
4743 /* because bt is reset and loss of the info. */
4744 if ((coex_sta->bt_info_ext & BIT(1))) {
4745 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4746 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
4747 BTC_TRACE(trace_buf);
4748 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4751 ex_halbtc8723b2ant_media_status_notify(
4752 btcoexist, BTC_MEDIA_CONNECT);
4754 ex_halbtc8723b2ant_media_status_notify(
4755 btcoexist, BTC_MEDIA_DISCONNECT);
4758 if ((coex_sta->bt_info_ext & BIT(3))) {
4759 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4760 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4761 BTC_TRACE(trace_buf);
4762 halbtc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
4765 /* BT already NOT ignore Wlan active, do nothing here. */
4767 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
4768 if ((coex_sta->bt_info_ext & BIT(4))) {
4769 /* BT auto report already enabled, do nothing */
4771 halbtc8723b2ant_bt_auto_report(btcoexist, FORCE_EXEC,
4776 /* check BIT2 first ==> check if bt is under inquiry or page scan */
4777 if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
4778 coex_sta->c2h_bt_inquiry_page = true;
4780 coex_sta->c2h_bt_inquiry_page = false;
4782 /* set link exist status */
4783 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4784 coex_sta->bt_link_exist = false;
4785 coex_sta->pan_exist = false;
4786 coex_sta->a2dp_exist = false;
4787 coex_sta->hid_exist = false;
4788 coex_sta->sco_exist = false;
4789 } else { /* connection exists */
4790 coex_sta->bt_link_exist = true;
4791 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
4792 coex_sta->pan_exist = true;
4794 coex_sta->pan_exist = false;
4795 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
4796 coex_sta->a2dp_exist = true;
4798 coex_sta->a2dp_exist = false;
4799 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
4800 coex_sta->hid_exist = true;
4802 coex_sta->hid_exist = false;
4803 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
4804 coex_sta->sco_exist = true;
4806 coex_sta->sco_exist = false;
4808 if ((coex_sta->hid_exist == false) &&
4809 (coex_sta->c2h_bt_inquiry_page == false) &&
4810 (coex_sta->sco_exist == false)) {
4811 if (coex_sta->high_priority_tx +
4812 coex_sta->high_priority_rx >= 160) {
4813 coex_sta->hid_exist = true;
4814 bt_info = bt_info | 0x28;
4819 halbtc8723b2ant_update_bt_link_info(btcoexist);
4821 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4822 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
4823 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4824 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4825 BTC_TRACE(trace_buf);
4826 } else if (bt_info ==
4827 BT_INFO_8723B_2ANT_B_CONNECTION) { /* connection exists but no busy */
4828 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
4829 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4830 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4831 BTC_TRACE(trace_buf);
4832 } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
4833 (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
4834 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
4835 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4836 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4837 BTC_TRACE(trace_buf);
4838 } else if (bt_info & BT_INFO_8723B_2ANT_B_ACL_BUSY) {
4839 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
4840 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4841 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4842 BTC_TRACE(trace_buf);
4844 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
4845 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4846 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4847 BTC_TRACE(trace_buf);
4850 if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
4851 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
4852 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
4857 limited_dig = false;
4860 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4862 coex_dm->limited_dig = limited_dig;
4863 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4865 halbtc8723b2ant_run_coexist_mechanism(btcoexist);
4868 void ex_halbtc8723b2ant_halt_notify(IN struct btc_coexist *btcoexist)
4870 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
4871 BTC_TRACE(trace_buf);
4873 halbtc8723b2ant_wifi_off_hw_cfg(btcoexist);
4874 /* remove due to interrupt is disabled that polling c2h will fail and delay 100ms. */
4875 /* btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x15); */ /*BT goto standby while GNT_BT 1-->0 */
4876 halbtc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4878 ex_halbtc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4881 void ex_halbtc8723b2ant_pnp_notify(IN struct btc_coexist *btcoexist,
4884 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Pnp notify\n");
4885 BTC_TRACE(trace_buf);
4887 if (BTC_WIFI_PNP_SLEEP == pnp_state) {
4888 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4889 "[BTCoex], Pnp notify to SLEEP\n");
4890 BTC_TRACE(trace_buf);
4892 /* Sinda 20150819, workaround for driver skip leave IPS/LPS to speed up sleep time. */
4893 /* Driver do not leave IPS/LPS when driver is going to sleep, so BTCoexistence think wifi is still under IPS/LPS */
4894 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch state after wakeup. */
4895 coex_sta->under_ips = false;
4896 coex_sta->under_lps = false;
4897 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
4898 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4899 "[BTCoex], Pnp notify to WAKE UP\n");
4900 BTC_TRACE(trace_buf);
4901 halbtc8723b2ant_init_hw_config(btcoexist, false);
4902 halbtc8723b2ant_init_coex_dm(btcoexist);
4903 halbtc8723b2ant_query_bt_info(btcoexist);
4907 void ex_halbtc8723b2ant_periodical(IN struct btc_coexist *btcoexist)
4911 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
4913 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4914 "[BTCoex], ==========================Periodical===========================\n");
4915 BTC_TRACE(trace_buf);
4916 if (coex_sta->dis_ver_info_cnt <= 5) {
4917 coex_sta->dis_ver_info_cnt += 1;
4918 if (coex_sta->dis_ver_info_cnt == 3) {
4919 /* Antenna config to set 0x765 = 0x0 (GNT_BT control by PTA) after initial */
4920 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4921 "[BTCoex], Set GNT_BT control by PTA\n");
4922 BTC_TRACE(trace_buf);
4923 halbtc8723b2ant_set_ant_path(btcoexist,
4924 BTC_ANT_WIFI_AT_MAIN, false, false);
4928 if (((coex_sta->bt_coex_supported_version == 0) ||
4929 (coex_sta->bt_coex_supported_version == 0xffff)) && (!coex_sta->bt_disabled))
4930 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_VERSION, &coex_sta->bt_coex_supported_version);
4933 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
4934 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
4936 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
4937 halbtc8723b2ant_query_bt_info(btcoexist);
4938 halbtc8723b2ant_monitor_bt_enable_disable(btcoexist);
4940 halbtc8723b2ant_monitor_bt_ctr(btcoexist);
4941 halbtc8723b2ant_monitor_wifi_ctr(btcoexist);
4943 /* for some BT speaker that Hi-Pri pkt appear begore start play, this will cause HID exist */
4944 if ((coex_sta->high_priority_tx + coex_sta->high_priority_rx < 50) &&
4945 (bt_link_info->hid_exist == true))
4946 bt_link_info->hid_exist = false;
4948 if (halbtc8723b2ant_is_wifi_status_changed(btcoexist) ||
4949 coex_dm->auto_tdma_adjust)
4950 halbtc8723b2ant_run_coexist_mechanism(btcoexist);
4956 #endif /* #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1) */