1 /***************************************************************
4 * This file is for RTL8723B Co-exist mechanism
7 * 2012/11/15 Cosa first check in.
9 ***************************************************************/
12 /***************************************************************
14 ***************************************************************/
15 #include "halbt_precomp.h"
17 /***************************************************************
18 * Global variables, these are static variables
19 ***************************************************************/
20 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant
;
21 static struct coex_dm_8723b_1ant
*coex_dm
= &glcoex_dm_8723b_1ant
;
22 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant
;
23 static struct coex_sta_8723b_1ant
*coex_sta
= &glcoex_sta_8723b_1ant
;
25 static const char *const GLBtInfoSrc8723b1Ant
[] = {
28 "BT Info[bt auto report]",
31 static u32 glcoex_ver_date_8723b_1ant
= 20130906;
32 static u32 glcoex_ver_8723b_1ant
= 0x45;
34 /***************************************************************
35 * local function proto type if needed
36 ***************************************************************/
37 /***************************************************************
38 * local function start with halbtc8723b1ant_
39 ***************************************************************/
40 static u8
halbtc8723b1ant_bt_rssi_state(u8 level_num
, u8 rssi_thresh
,
44 u8 bt_rssi_state
= coex_sta
->pre_bt_rssi_state
;
46 bt_rssi
= coex_sta
->bt_rssi
;
49 if ((coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_LOW
) ||
50 (coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_STAY_LOW
)) {
51 if (bt_rssi
>= rssi_thresh
+
52 BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT
) {
53 bt_rssi_state
= BTC_RSSI_STATE_HIGH
;
54 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
55 "[BTCoex], BT Rssi state "
58 bt_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
59 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
60 "[BTCoex], BT Rssi state "
64 if (bt_rssi
< rssi_thresh
) {
65 bt_rssi_state
= BTC_RSSI_STATE_LOW
;
66 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
67 "[BTCoex], BT Rssi state "
70 bt_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
71 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
72 "[BTCoex], BT Rssi state "
76 } else if (level_num
== 3) {
77 if (rssi_thresh
> rssi_thresh1
) {
78 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
79 "[BTCoex], BT Rssi thresh error!!\n");
80 return coex_sta
->pre_bt_rssi_state
;
83 if ((coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_LOW
) ||
84 (coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_STAY_LOW
)) {
85 if (bt_rssi
>= rssi_thresh
+
86 BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT
) {
87 bt_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
88 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
89 "[BTCoex], BT Rssi state "
90 "switch to Medium\n");
92 bt_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
93 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
94 "[BTCoex], BT Rssi state "
97 } else if ((coex_sta
->pre_bt_rssi_state
==
98 BTC_RSSI_STATE_MEDIUM
) ||
99 (coex_sta
->pre_bt_rssi_state
==
100 BTC_RSSI_STATE_STAY_MEDIUM
)) {
101 if (bt_rssi
>= rssi_thresh1
+
102 BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT
) {
103 bt_rssi_state
= BTC_RSSI_STATE_HIGH
;
104 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
105 "[BTCoex], BT Rssi state "
107 } else if (bt_rssi
< rssi_thresh
) {
108 bt_rssi_state
= BTC_RSSI_STATE_LOW
;
109 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
110 "[BTCoex], BT Rssi state "
113 bt_rssi_state
= BTC_RSSI_STATE_STAY_MEDIUM
;
114 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
115 "[BTCoex], BT Rssi state "
119 if (bt_rssi
< rssi_thresh1
) {
120 bt_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
121 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
122 "[BTCoex], BT Rssi state "
123 "switch to Medium\n");
125 bt_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
126 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
127 "[BTCoex], BT Rssi state "
133 coex_sta
->pre_bt_rssi_state
= bt_rssi_state
;
135 return bt_rssi_state
;
138 static u8
halbtc8723b1ant_wifi_rssi_state(struct btc_coexist
*btcoexist
,
139 u8 index
, u8 level_num
,
140 u8 rssi_thresh
, u8 rssi_thresh1
)
143 u8 wifi_rssi_state
= coex_sta
->pre_wifi_rssi_state
[index
];
145 btcoexist
->btc_get(btcoexist
,
146 BTC_GET_S4_WIFI_RSSI
, &wifi_rssi
);
148 if (level_num
== 2) {
149 if ((coex_sta
->pre_wifi_rssi_state
[index
] ==
150 BTC_RSSI_STATE_LOW
) ||
151 (coex_sta
->pre_wifi_rssi_state
[index
] ==
152 BTC_RSSI_STATE_STAY_LOW
)) {
153 if (wifi_rssi
>= rssi_thresh
+
154 BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT
) {
155 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
156 BTC_PRINT(BTC_MSG_ALGORITHM
,
157 ALGO_WIFI_RSSI_STATE
,
158 "[BTCoex], wifi RSSI state "
161 wifi_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
162 BTC_PRINT(BTC_MSG_ALGORITHM
,
163 ALGO_WIFI_RSSI_STATE
,
164 "[BTCoex], wifi RSSI state "
168 if (wifi_rssi
< rssi_thresh
) {
169 wifi_rssi_state
= BTC_RSSI_STATE_LOW
;
170 BTC_PRINT(BTC_MSG_ALGORITHM
,
171 ALGO_WIFI_RSSI_STATE
,
172 "[BTCoex], wifi RSSI state "
175 wifi_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
176 BTC_PRINT(BTC_MSG_ALGORITHM
,
177 ALGO_WIFI_RSSI_STATE
,
178 "[BTCoex], wifi RSSI state "
182 } else if (level_num
== 3) {
183 if (rssi_thresh
> rssi_thresh1
) {
184 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_WIFI_RSSI_STATE
,
185 "[BTCoex], wifi RSSI thresh error!!\n");
186 return coex_sta
->pre_wifi_rssi_state
[index
];
189 if ((coex_sta
->pre_wifi_rssi_state
[index
] ==
190 BTC_RSSI_STATE_LOW
) ||
191 (coex_sta
->pre_wifi_rssi_state
[index
] ==
192 BTC_RSSI_STATE_STAY_LOW
)) {
193 if (wifi_rssi
>= rssi_thresh
+
194 BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT
) {
195 wifi_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
196 BTC_PRINT(BTC_MSG_ALGORITHM
,
197 ALGO_WIFI_RSSI_STATE
,
198 "[BTCoex], wifi RSSI state "
199 "switch to Medium\n");
201 wifi_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
202 BTC_PRINT(BTC_MSG_ALGORITHM
,
203 ALGO_WIFI_RSSI_STATE
,
204 "[BTCoex], wifi RSSI state "
207 } else if ((coex_sta
->pre_wifi_rssi_state
[index
] ==
208 BTC_RSSI_STATE_MEDIUM
) ||
209 (coex_sta
->pre_wifi_rssi_state
[index
] ==
210 BTC_RSSI_STATE_STAY_MEDIUM
)) {
211 if (wifi_rssi
>= rssi_thresh1
+
212 BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT
) {
213 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
214 BTC_PRINT(BTC_MSG_ALGORITHM
,
215 ALGO_WIFI_RSSI_STATE
,
216 "[BTCoex], wifi RSSI state "
218 } else if (wifi_rssi
< rssi_thresh
) {
219 wifi_rssi_state
= BTC_RSSI_STATE_LOW
;
220 BTC_PRINT(BTC_MSG_ALGORITHM
,
221 ALGO_WIFI_RSSI_STATE
,
222 "[BTCoex], wifi RSSI state "
225 wifi_rssi_state
= BTC_RSSI_STATE_STAY_MEDIUM
;
226 BTC_PRINT(BTC_MSG_ALGORITHM
,
227 ALGO_WIFI_RSSI_STATE
,
228 "[BTCoex], wifi RSSI state "
232 if (wifi_rssi
< rssi_thresh1
) {
233 wifi_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
234 BTC_PRINT(BTC_MSG_ALGORITHM
,
235 ALGO_WIFI_RSSI_STATE
,
236 "[BTCoex], wifi RSSI state "
237 "switch to Medium\n");
239 wifi_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
240 BTC_PRINT(BTC_MSG_ALGORITHM
,
241 ALGO_WIFI_RSSI_STATE
,
242 "[BTCoex], wifi RSSI state "
248 coex_sta
->pre_wifi_rssi_state
[index
] = wifi_rssi_state
;
250 return wifi_rssi_state
;
253 static void halbtc8723b1ant_updatera_mask(struct btc_coexist
*btcoexist
,
254 bool force_exec
, u32 dis_rate_mask
)
256 coex_dm
->curra_mask
= dis_rate_mask
;
258 if (force_exec
|| (coex_dm
->prera_mask
!= coex_dm
->curra_mask
))
259 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_UPDATE_ra_mask
,
260 &coex_dm
->curra_mask
);
262 coex_dm
->prera_mask
= coex_dm
->curra_mask
;
265 static void halbtc8723b1ant_auto_rate_fallback_retry(
266 struct btc_coexist
*btcoexist
,
267 bool force_exec
, u8 type
)
269 bool wifi_under_bmode
= false;
271 coex_dm
->cur_arfr_type
= type
;
273 if (force_exec
|| (coex_dm
->pre_arfr_type
!= coex_dm
->cur_arfr_type
)) {
274 switch (coex_dm
->cur_arfr_type
) {
275 case 0: /* normal mode */
276 btcoexist
->btc_write_4byte(btcoexist
, 0x430,
277 coex_dm
->backup_arfr_cnt1
);
278 btcoexist
->btc_write_4byte(btcoexist
, 0x434,
279 coex_dm
->backup_arfr_cnt2
);
282 btcoexist
->btc_get(btcoexist
,
283 BTC_GET_BL_WIFI_UNDER_B_MODE
,
285 if (wifi_under_bmode
) {
286 btcoexist
->btc_write_4byte(btcoexist
,
288 btcoexist
->btc_write_4byte(btcoexist
,
291 btcoexist
->btc_write_4byte(btcoexist
,
293 btcoexist
->btc_write_4byte(btcoexist
,
302 coex_dm
->pre_arfr_type
= coex_dm
->cur_arfr_type
;
305 static void halbtc8723b1ant_retry_limit(struct btc_coexist
*btcoexist
,
306 bool force_exec
, u8 type
)
308 coex_dm
->cur_retry_limit_type
= type
;
310 if (force_exec
|| (coex_dm
->pre_retry_limit_type
!=
311 coex_dm
->cur_retry_limit_type
)) {
313 switch (coex_dm
->cur_retry_limit_type
) {
314 case 0: /* normal mode */
315 btcoexist
->btc_write_2byte(btcoexist
, 0x42a,
316 coex_dm
->backup_retry_limit
);
318 case 1: /* retry limit=8 */
319 btcoexist
->btc_write_2byte(btcoexist
, 0x42a, 0x0808);
326 coex_dm
->pre_retry_limit_type
= coex_dm
->cur_retry_limit_type
;
329 static void halbtc8723b1ant_ampdu_maxtime(struct btc_coexist
*btcoexist
,
330 bool force_exec
, u8 type
)
332 coex_dm
->cur_ampdu_time_type
= type
;
334 if (force_exec
|| (coex_dm
->pre_ampdu_time_type
!=
335 coex_dm
->cur_ampdu_time_type
)) {
336 switch (coex_dm
->cur_ampdu_time_type
) {
337 case 0: /* normal mode */
338 btcoexist
->btc_write_1byte(btcoexist
, 0x456,
339 coex_dm
->backup_ampdu_max_time
);
341 case 1: /* AMPDU timw = 0x38 * 32us */
342 btcoexist
->btc_write_1byte(btcoexist
,
350 coex_dm
->pre_ampdu_time_type
= coex_dm
->cur_ampdu_time_type
;
353 static void halbtc8723b1ant_limited_tx(struct btc_coexist
*btcoexist
,
354 bool force_exec
, u8 ra_maskType
, u8 arfr_type
,
355 u8 retry_limit_type
, u8 ampdu_time_type
)
357 switch (ra_maskType
) {
358 case 0: /* normal mode */
359 halbtc8723b1ant_updatera_mask(btcoexist
, force_exec
, 0x0);
361 case 1: /* disable cck 1/2 */
362 halbtc8723b1ant_updatera_mask(btcoexist
, force_exec
,
365 /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4*/
367 halbtc8723b1ant_updatera_mask(btcoexist
, force_exec
,
374 halbtc8723b1ant_auto_rate_fallback_retry(btcoexist
, force_exec
,
376 halbtc8723b1ant_retry_limit(btcoexist
, force_exec
, retry_limit_type
);
377 halbtc8723b1ant_ampdu_maxtime(btcoexist
, force_exec
, ampdu_time_type
);
380 static void halbtc8723b1ant_limited_rx(struct btc_coexist
*btcoexist
,
381 bool force_exec
, bool rej_ap_agg_pkt
,
382 bool b_bt_ctrl_agg_buf_size
, u8 agg_buf_size
)
384 bool reject_rx_agg
= rej_ap_agg_pkt
;
385 bool bt_ctrl_rx_agg_size
= b_bt_ctrl_agg_buf_size
;
386 u8 rxAggSize
= agg_buf_size
;
388 /**********************************************
389 * Rx Aggregation related setting
390 **********************************************/
391 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_TO_REJ_AP_AGG_PKT
,
393 /* decide BT control aggregation buf size or not */
394 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_CTRL_AGG_SIZE
,
395 &bt_ctrl_rx_agg_size
);
396 /* aggregation buf size, only work
397 *when BT control Rx aggregation size. */
398 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_AGG_BUF_SIZE
, &rxAggSize
);
399 /* real update aggregation setting */
400 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_AGGREGATE_CTRL
, NULL
);
403 static void halbtc8723b1ant_monitor_bt_ctr(struct btc_coexist
*btcoexist
)
405 u32 reg_hp_txrx
, reg_lp_txrx
, u32tmp
;
406 u32 reg_hp_tx
= 0, reg_hp_rx
= 0;
407 u32 reg_lp_tx
= 0, reg_lp_rx
= 0;
412 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, reg_hp_txrx
);
413 reg_hp_tx
= u32tmp
& MASKLWORD
;
414 reg_hp_rx
= (u32tmp
& MASKHWORD
) >> 16;
416 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, reg_lp_txrx
);
417 reg_lp_tx
= u32tmp
& MASKLWORD
;
418 reg_lp_rx
= (u32tmp
& MASKHWORD
) >> 16;
420 coex_sta
->high_priority_tx
= reg_hp_tx
;
421 coex_sta
->high_priority_rx
= reg_hp_rx
;
422 coex_sta
->low_priority_tx
= reg_lp_tx
;
423 coex_sta
->low_priority_rx
= reg_lp_rx
;
426 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0xc);
429 static void halbtc8723b1ant_query_bt_info(struct btc_coexist
*btcoexist
)
431 u8 h2c_parameter
[1] = {0};
433 coex_sta
->c2h_bt_info_req_sent
= true;
435 h2c_parameter
[0] |= BIT0
; /* trigger*/
437 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
438 "[BTCoex], Query Bt Info, FW write 0x61=0x%x\n",
441 btcoexist
->btc_fill_h2c(btcoexist
, 0x61, 1, h2c_parameter
);
444 static bool halbtc8723b1ant_is_wifi_status_changed(
445 struct btc_coexist
*btcoexist
)
447 static bool pre_wifi_busy
= false;
448 static bool pre_under_4way
= false, pre_bt_hs_on
= false;
449 bool wifi_busy
= false, under_4way
= false, bt_hs_on
= false;
450 bool wifi_connected
= false;
452 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
454 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
455 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
456 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_4_WAY_PROGRESS
,
459 if (wifi_connected
) {
460 if (wifi_busy
!= pre_wifi_busy
) {
461 pre_wifi_busy
= wifi_busy
;
464 if (under_4way
!= pre_under_4way
) {
465 pre_under_4way
= under_4way
;
468 if (bt_hs_on
!= pre_bt_hs_on
) {
469 pre_bt_hs_on
= bt_hs_on
;
477 static void halbtc8723b1ant_update_bt_link_info(struct btc_coexist
*btcoexist
)
479 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
480 bool bt_hs_on
= false;
482 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
484 bt_link_info
->bt_link_exist
= coex_sta
->bt_link_exist
;
485 bt_link_info
->sco_exist
= coex_sta
->sco_exist
;
486 bt_link_info
->a2dp_exist
= coex_sta
->a2dp_exist
;
487 bt_link_info
->pan_exist
= coex_sta
->pan_exist
;
488 bt_link_info
->hid_exist
= coex_sta
->hid_exist
;
490 /* work around for HS mode. */
492 bt_link_info
->pan_exist
= true;
493 bt_link_info
->bt_link_exist
= true;
496 /* check if Sco only */
497 if (bt_link_info
->sco_exist
&& !bt_link_info
->a2dp_exist
&&
498 !bt_link_info
->pan_exist
&& !bt_link_info
->hid_exist
)
499 bt_link_info
->sco_only
= true;
501 bt_link_info
->sco_only
= false;
503 /* check if A2dp only */
504 if (!bt_link_info
->sco_exist
&& bt_link_info
->a2dp_exist
&&
505 !bt_link_info
->pan_exist
&& !bt_link_info
->hid_exist
)
506 bt_link_info
->a2dp_only
= true;
508 bt_link_info
->a2dp_only
= false;
510 /* check if Pan only */
511 if (!bt_link_info
->sco_exist
&& !bt_link_info
->a2dp_exist
&&
512 bt_link_info
->pan_exist
&& !bt_link_info
->hid_exist
)
513 bt_link_info
->pan_only
= true;
515 bt_link_info
->pan_only
= false;
517 /* check if Hid only */
518 if (!bt_link_info
->sco_exist
&& !bt_link_info
->a2dp_exist
&&
519 !bt_link_info
->pan_exist
&& bt_link_info
->hid_exist
)
520 bt_link_info
->hid_only
= true;
522 bt_link_info
->hid_only
= false;
525 static u8
halbtc8723b1ant_action_algorithm(struct btc_coexist
*btcoexist
)
527 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
528 bool bt_hs_on
= false;
529 u8 algorithm
= BT_8723B_1ANT_COEX_ALGO_UNDEFINED
;
530 u8 numOfDiffProfile
= 0;
532 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
534 if (!bt_link_info
->bt_link_exist
) {
535 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
536 "[BTCoex], No BT link exists!!!\n");
540 if (bt_link_info
->sco_exist
)
542 if (bt_link_info
->hid_exist
)
544 if (bt_link_info
->pan_exist
)
546 if (bt_link_info
->a2dp_exist
)
549 if (numOfDiffProfile
== 1) {
550 if (bt_link_info
->sco_exist
) {
551 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
552 "[BTCoex], BT Profile = SCO only\n");
553 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
555 if (bt_link_info
->hid_exist
) {
556 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
557 "[BTCoex], BT Profile = HID only\n");
558 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID
;
559 } else if (bt_link_info
->a2dp_exist
) {
560 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
561 "[BTCoex], BT Profile = A2DP only\n");
562 algorithm
= BT_8723B_1ANT_COEX_ALGO_A2DP
;
563 } else if (bt_link_info
->pan_exist
) {
565 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
566 "[BTCoex], BT Profile = "
569 BT_8723B_1ANT_COEX_ALGO_PANHS
;
571 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
572 "[BTCoex], BT Profile = "
575 BT_8723B_1ANT_COEX_ALGO_PANEDR
;
579 } else if (numOfDiffProfile
== 2) {
580 if (bt_link_info
->sco_exist
) {
581 if (bt_link_info
->hid_exist
) {
582 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
583 "[BTCoex], BT Profile = SCO + HID\n");
584 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID
;
585 } else if (bt_link_info
->a2dp_exist
) {
586 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
587 "[BTCoex], BT Profile = "
588 "SCO + A2DP ==> SCO\n");
589 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
590 } else if (bt_link_info
->pan_exist
) {
592 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
593 "[BTCoex], BT Profile "
594 "= SCO + PAN(HS)\n");
595 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
597 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
598 "[BTCoex], BT Profile "
599 "= SCO + PAN(EDR)\n");
601 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
605 if (bt_link_info
->hid_exist
&&
606 bt_link_info
->a2dp_exist
) {
607 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
608 "[BTCoex], BT Profile = "
610 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
611 } else if (bt_link_info
->hid_exist
&&
612 bt_link_info
->pan_exist
) {
614 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
615 "[BTCoex], BT Profile = "
618 BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
620 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
621 "[BTCoex], BT Profile = "
624 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
626 } else if (bt_link_info
->pan_exist
&&
627 bt_link_info
->a2dp_exist
) {
629 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
630 "[BTCoex], BT Profile = "
633 BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS
;
635 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
636 "[BTCoex], BT Profile = "
637 "A2DP + PAN(EDR)\n");
639 BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP
;
643 } else if (numOfDiffProfile
== 3) {
644 if (bt_link_info
->sco_exist
) {
645 if (bt_link_info
->hid_exist
&&
646 bt_link_info
->a2dp_exist
) {
647 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
648 "[BTCoex], BT Profile = "
649 "SCO + HID + A2DP ==> HID\n");
650 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID
;
651 } else if (bt_link_info
->hid_exist
&&
652 bt_link_info
->pan_exist
) {
654 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
655 "[BTCoex], BT Profile = "
656 "SCO + HID + PAN(HS)\n");
658 BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
660 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
661 "[BTCoex], BT Profile = "
662 "SCO + HID + PAN(EDR)\n");
664 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
666 } else if (bt_link_info
->pan_exist
&&
667 bt_link_info
->a2dp_exist
) {
669 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
670 "[BTCoex], BT Profile = "
671 "SCO + A2DP + PAN(HS)\n");
672 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
674 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
675 "[BTCoex], BT Profile = SCO + "
676 "A2DP + PAN(EDR) ==> HID\n");
678 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
682 if (bt_link_info
->hid_exist
&&
683 bt_link_info
->pan_exist
&&
684 bt_link_info
->a2dp_exist
) {
686 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
687 "[BTCoex], BT Profile = "
688 "HID + A2DP + PAN(HS)\n");
690 BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
692 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
693 "[BTCoex], BT Profile = "
694 "HID + A2DP + PAN(EDR)\n");
696 BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR
;
700 } else if (numOfDiffProfile
>= 3) {
701 if (bt_link_info
->sco_exist
) {
702 if (bt_link_info
->hid_exist
&&
703 bt_link_info
->pan_exist
&&
704 bt_link_info
->a2dp_exist
) {
706 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
707 "[BTCoex], Error!!! "
708 "BT Profile = SCO + "
709 "HID + A2DP + PAN(HS)\n");
711 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
712 "[BTCoex], BT Profile = "
713 "SCO + HID + A2DP + PAN(EDR)"
714 "==>PAN(EDR)+HID\n");
716 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
725 static bool halbtc8723b1ant_need_to_dec_bt_pwr(struct btc_coexist
*btcoexist
)
728 bool bt_hs_on
= false, wifi_connected
= false;
732 if (!btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
))
734 if (!btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
737 if (!btcoexist
->btc_get(btcoexist
, BTC_GET_S4_HS_RSSI
, &bt_hs_rssi
))
740 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 35, 0);
742 if (wifi_connected
) {
747 if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
748 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
))
756 static void halbtc8723b1ant_set_fw_dac_swing_level(
757 struct btc_coexist
*btcoexist
,
760 u8 h2c_parameter
[1] = {0};
762 /* There are several type of dacswing
763 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
764 h2c_parameter
[0] = dac_swing_lvl
;
766 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
767 "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl
);
768 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
769 "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter
[0]);
771 btcoexist
->btc_fill_h2c(btcoexist
, 0x64, 1, h2c_parameter
);
774 static void halbtc8723b1ant_set_fw_dec_bt_pwr(struct btc_coexist
*btcoexist
,
777 u8 h2c_parameter
[1] = {0};
779 h2c_parameter
[0] = 0;
782 h2c_parameter
[0] |= BIT1
;
784 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
785 "[BTCoex], decrease Bt Power : %s, FW write 0x62=0x%x\n",
786 (dec_bt_pwr
? "Yes!!":"No!!"),h2c_parameter
[0]);
788 btcoexist
->btc_fill_h2c(btcoexist
, 0x62, 1, h2c_parameter
);
791 static void halbtc8723b1ant_dec_bt_pwr(struct btc_coexist
*btcoexist
,
792 bool force_exec
, bool dec_bt_pwr
)
795 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
796 "[BTCoex], %s Dec BT power = %s\n",
797 (force_exec
? "force to" : ""), (dec_bt_pwr
? "ON" : "OFF"));
798 coex_dm
->cur_dec_bt_pwr
= dec_bt_pwr
;
801 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
802 "[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n",
803 coex_dm
->pre_dec_bt_pwr
, coex_dm
->cur_dec_bt_pwr
);
805 if (coex_dm
->pre_dec_bt_pwr
== coex_dm
->cur_dec_bt_pwr
)
808 halbtc8723b1ant_set_fw_dec_bt_pwr(btcoexist
, coex_dm
->cur_dec_bt_pwr
);
810 coex_dm
->pre_dec_bt_pwr
= coex_dm
->cur_dec_bt_pwr
;
813 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
814 static void halbtc8723b1ant_set_bt_auto_report(struct btc_coexist
*btcoexist
,
815 bool enable_auto_report
)
817 u8 h2c_parameter
[1] = {0};
819 h2c_parameter
[0] = 0;
821 if (enable_auto_report
)
822 h2c_parameter
[0] |= BIT0
;
824 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
825 "[BTCoex], BT FW auto report : %s, FW write 0x68=0x%x\n",
826 (enable_auto_report
? "Enabled!!":"Disabled!!"),
829 btcoexist
->btc_fill_h2c(btcoexist
, 0x68, 1, h2c_parameter
);
832 static void halbtc8723b1ant_bt_auto_report(struct btc_coexist
*btcoexist
,
833 bool force_exec
, bool enable_auto_report
)
835 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
836 "[BTCoex], %s BT Auto report = %s\n",
837 (force_exec
? "force to":""),
838 ((enable_auto_report
)? "Enabled":"Disabled"));
839 coex_dm
->cur_bt_auto_report
= enable_auto_report
;
842 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
843 "[BTCoex], bPreBtAutoReport=%d, "
844 "bCurBtAutoReport=%d\n",
845 coex_dm
->pre_bt_auto_report
,
846 coex_dm
->cur_bt_auto_report
);
848 if (coex_dm
->pre_bt_auto_report
== coex_dm
->cur_bt_auto_report
)
851 halbtc8723b1ant_set_bt_auto_report(btcoexist
,
852 coex_dm
->cur_bt_auto_report
);
854 coex_dm
->pre_bt_auto_report
= coex_dm
->cur_bt_auto_report
;
858 static void halbtc8723b1ant_fw_dac_swing_lvl(struct btc_coexist
*btcoexist
,
859 bool force_exec
, u8 fw_dac_swing_lvl
)
862 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
863 "[BTCoex], %s set FW Dac Swing level = %d\n",
864 (force_exec
? "force to":""), fw_dac_swing_lvl
);
865 coex_dm
->cur_fw_dac_swing_lvl
= fw_dac_swing_lvl
;
868 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
869 "[BTCoex], preFwDacSwingLvl=%d, "
870 "curFwDacSwingLvl=%d\n",
871 coex_dm
->pre_fw_dac_swing_lvl
,
872 coex_dm
->cur_fw_dac_swing_lvl
);
874 if (coex_dm
->pre_fw_dac_swing_lvl
==
875 coex_dm
->cur_fw_dac_swing_lvl
)
879 halbtc8723b1ant_set_fw_dac_swing_level(btcoexist
,
880 coex_dm
->cur_fw_dac_swing_lvl
);
882 coex_dm
->pre_fw_dac_swing_lvl
= coex_dm
->cur_fw_dac_swing_lvl
;
885 static void halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(
886 struct btc_coexist
*btcoexist
,
889 u8 h2c_parameter
[6] = {0};
891 h2c_parameter
[0] = 0x6; /* opCode, 0x6= Retry_Penalty */
893 if (low_penalty_ra
) {
894 h2c_parameter
[1] |= BIT0
;
895 /*normal rate except MCS7/6/5, OFDM54/48/36 */
896 h2c_parameter
[2] = 0x00;
897 h2c_parameter
[3] = 0xf7; /*MCS7 or OFDM54 */
898 h2c_parameter
[4] = 0xf8; /*MCS6 or OFDM48 */
899 h2c_parameter
[5] = 0xf9; /*MCS5 or OFDM36 */
902 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
903 "[BTCoex], set WiFi Low-Penalty Retry: %s",
904 (low_penalty_ra
? "ON!!" : "OFF!!"));
906 btcoexist
->btc_fill_h2c(btcoexist
, 0x69, 6, h2c_parameter
);
909 static void halbtc8723b1ant_low_penalty_ra(struct btc_coexist
*btcoexist
,
910 bool force_exec
, bool low_penalty_ra
)
912 coex_dm
->cur_low_penalty_ra
= low_penalty_ra
;
915 if (coex_dm
->pre_low_penalty_ra
== coex_dm
->cur_low_penalty_ra
)
918 halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(btcoexist
,
919 coex_dm
->cur_low_penalty_ra
);
921 coex_dm
->pre_low_penalty_ra
= coex_dm
->cur_low_penalty_ra
;
924 static void halbtc8723b1ant_set_coex_table(struct btc_coexist
*btcoexist
,
925 u32 val0x6c0
, u32 val0x6c4
,
926 u32 val0x6c8
, u8 val0x6cc
)
928 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
929 "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0
);
930 btcoexist
->btc_write_4byte(btcoexist
, 0x6c0, val0x6c0
);
932 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
933 "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4
);
934 btcoexist
->btc_write_4byte(btcoexist
, 0x6c4, val0x6c4
);
936 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
937 "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8
);
938 btcoexist
->btc_write_4byte(btcoexist
, 0x6c8, val0x6c8
);
940 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
941 "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc
);
942 btcoexist
->btc_write_1byte(btcoexist
, 0x6cc, val0x6cc
);
945 static void halbtc8723b1ant_coex_table(struct btc_coexist
*btcoexist
,
946 bool force_exec
, u32 val0x6c0
,
947 u32 val0x6c4
, u32 val0x6c8
,
950 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW
,
951 "[BTCoex], %s write Coex Table 0x6c0=0x%x,"
952 " 0x6c4=0x%x, 0x6cc=0x%x\n", (force_exec
? "force to" : ""),
953 val0x6c0
, val0x6c4
, val0x6cc
);
954 coex_dm
->cur_val0x6c0
= val0x6c0
;
955 coex_dm
->cur_val0x6c4
= val0x6c4
;
956 coex_dm
->cur_val0x6c8
= val0x6c8
;
957 coex_dm
->cur_val0x6cc
= val0x6cc
;
960 if ((coex_dm
->pre_val0x6c0
== coex_dm
->cur_val0x6c0
) &&
961 (coex_dm
->pre_val0x6c4
== coex_dm
->cur_val0x6c4
) &&
962 (coex_dm
->pre_val0x6c8
== coex_dm
->cur_val0x6c8
) &&
963 (coex_dm
->pre_val0x6cc
== coex_dm
->cur_val0x6cc
))
966 halbtc8723b1ant_set_coex_table(btcoexist
, val0x6c0
, val0x6c4
,
969 coex_dm
->pre_val0x6c0
= coex_dm
->cur_val0x6c0
;
970 coex_dm
->pre_val0x6c4
= coex_dm
->cur_val0x6c4
;
971 coex_dm
->pre_val0x6c8
= coex_dm
->cur_val0x6c8
;
972 coex_dm
->pre_val0x6cc
= coex_dm
->cur_val0x6cc
;
975 static void halbtc8723b1ant_coex_table_with_type(struct btc_coexist
*btcoexist
,
976 bool force_exec
, u8 type
)
980 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
981 0x55555555, 0xffffff, 0x3);
984 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
985 0x5a5a5a5a, 0xffffff, 0x3);
988 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x5a5a5a5a,
989 0x5a5a5a5a, 0xffffff, 0x3);
992 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
993 0xaaaaaaaa, 0xffffff, 0x3);
996 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
997 0x5aaa5aaa, 0xffffff, 0x3);
1000 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x5a5a5a5a,
1001 0xaaaa5a5a, 0xffffff, 0x3);
1004 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
1005 0xaaaa5a5a, 0xffffff, 0x3);
1008 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x5afa5afa,
1009 0x5afa5afa, 0xffffff, 0x3);
1016 static void halbtc8723b1ant_SetFwIgnoreWlanAct(struct btc_coexist
*btcoexist
,
1019 u8 h2c_parameter
[1] = {0};
1022 h2c_parameter
[0] |= BIT0
; /* function enable */
1024 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
1025 "[BTCoex], set FW for BT Ignore Wlan_Act,"
1026 " FW write 0x63=0x%x\n", h2c_parameter
[0]);
1028 btcoexist
->btc_fill_h2c(btcoexist
, 0x63, 1, h2c_parameter
);
1031 static void halbtc8723b1ant_ignore_wlan_act(struct btc_coexist
*btcoexist
,
1032 bool force_exec
, bool enable
)
1034 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
1035 "[BTCoex], %s turn Ignore WlanAct %s\n",
1036 (force_exec
? "force to" : ""), (enable
? "ON" : "OFF"));
1037 coex_dm
->cur_ignore_wlan_act
= enable
;
1040 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1041 "[BTCoex], bPreIgnoreWlanAct = %d, "
1042 "bCurIgnoreWlanAct = %d!!\n",
1043 coex_dm
->pre_ignore_wlan_act
,
1044 coex_dm
->cur_ignore_wlan_act
);
1046 if (coex_dm
->pre_ignore_wlan_act
==
1047 coex_dm
->cur_ignore_wlan_act
)
1050 halbtc8723b1ant_SetFwIgnoreWlanAct(btcoexist
, enable
);
1052 coex_dm
->pre_ignore_wlan_act
= coex_dm
->cur_ignore_wlan_act
;
1055 static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist
*btcoexist
,
1056 u8 byte1
, u8 byte2
, u8 byte3
,
1059 u8 h2c_parameter
[5] = {0};
1060 u8 real_byte1
= byte1
, real_byte5
= byte5
;
1061 bool ap_enable
= false;
1063 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_AP_MODE_ENABLE
,
1067 if ((byte1
& BIT4
) && !(byte1
& BIT5
)) {
1068 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
1069 "[BTCoex], FW for 1Ant AP mode\n");
1070 real_byte1
&= ~BIT4
;
1074 real_byte5
&= ~BIT6
;
1078 h2c_parameter
[0] = real_byte1
;
1079 h2c_parameter
[1] = byte2
;
1080 h2c_parameter
[2] = byte3
;
1081 h2c_parameter
[3] = byte4
;
1082 h2c_parameter
[4] = real_byte5
;
1084 coex_dm
->ps_tdma_para
[0] = real_byte1
;
1085 coex_dm
->ps_tdma_para
[1] = byte2
;
1086 coex_dm
->ps_tdma_para
[2] = byte3
;
1087 coex_dm
->ps_tdma_para
[3] = byte4
;
1088 coex_dm
->ps_tdma_para
[4] = real_byte5
;
1090 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
1091 "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
1093 h2c_parameter
[1] << 24 |
1094 h2c_parameter
[2] << 16 |
1095 h2c_parameter
[3] << 8 |
1098 btcoexist
->btc_fill_h2c(btcoexist
, 0x60, 5, h2c_parameter
);
1101 static void halbtc8723b1ant_SetLpsRpwm(struct btc_coexist
*btcoexist
,
1102 u8 lps_val
, u8 rpwm_val
)
1107 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_1ANT_LPS
, &lps
);
1108 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_1ANT_RPWM
, &rpwm
);
1111 static void halbtc8723b1ant_LpsRpwm(struct btc_coexist
*btcoexist
,
1112 bool force_exec
, u8 lps_val
, u8 rpwm_val
)
1115 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
1116 "[BTCoex], %s set lps/rpwm=0x%x/0x%x \n",
1117 (force_exec
? "force to" : ""), lps_val
, rpwm_val
);
1118 coex_dm
->cur_lps
= lps_val
;
1119 coex_dm
->cur_rpwm
= rpwm_val
;
1122 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1123 "[BTCoex], LPS-RxBeaconMode=0x%x , LPS-RPWM=0x%x!!\n",
1124 coex_dm
->cur_lps
, coex_dm
->cur_rpwm
);
1126 if ((coex_dm
->pre_lps
== coex_dm
->cur_lps
) &&
1127 (coex_dm
->pre_rpwm
== coex_dm
->cur_rpwm
)) {
1128 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1129 "[BTCoex], LPS-RPWM_Last=0x%x"
1130 " , LPS-RPWM_Now=0x%x!!\n",
1131 coex_dm
->pre_rpwm
, coex_dm
->cur_rpwm
);
1136 halbtc8723b1ant_SetLpsRpwm(btcoexist
, lps_val
, rpwm_val
);
1138 coex_dm
->pre_lps
= coex_dm
->cur_lps
;
1139 coex_dm
->pre_rpwm
= coex_dm
->cur_rpwm
;
1142 static void halbtc8723b1ant_sw_mechanism1(struct btc_coexist
*btcoexist
,
1143 bool shrink_rx_lpf
, bool low_penalty_ra
,
1144 bool limited_dig
, bool bt_lna_constrain
)
1146 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1147 "[BTCoex], SM1[ShRf/ LpRA/ LimDig/ btLna] = %d %d %d %d\n",
1148 shrink_rx_lpf
, low_penalty_ra
, limited_dig
, bt_lna_constrain
);
1150 halbtc8723b1ant_low_penalty_ra(btcoexist
, NORMAL_EXEC
, low_penalty_ra
);
1153 static void halbtc8723b1ant_sw_mechanism2(struct btc_coexist
*btcoexist
,
1154 bool agc_table_shift
, bool adc_backoff
,
1155 bool sw_dac_swing
, u32 dac_swing_lvl
)
1157 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1158 "[BTCoex], SM2[AgcT/ AdcB/ SwDacSwing(lvl)] = %d %d %d\n",
1159 agc_table_shift
, adc_backoff
, sw_dac_swing
);
1162 static void halbtc8723b1ant_SetAntPath(struct btc_coexist
*btcoexist
,
1163 u8 ant_pos_type
, bool init_hw_cfg
,
1166 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
1167 u32 fw_ver
= 0, u32tmp
= 0;
1168 bool pg_ext_switch
= false;
1169 bool use_ext_switch
= false;
1170 u8 h2c_parameter
[2] = {0};
1172 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_EXT_SWITCH
, &pg_ext_switch
);
1173 /* [31:16]=fw ver, [15:0]=fw sub ver */
1174 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
1177 if ((fw_ver
< 0xc0000) || pg_ext_switch
)
1178 use_ext_switch
= true;
1181 /*BT select s0/s1 is controlled by WiFi */
1182 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x67, 0x20, 0x1);
1184 /*Force GNT_BT to Normal */
1185 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x765, 0x18, 0x0);
1186 } else if (wifi_off
) {
1187 /*Force GNT_BT to High */
1188 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x765, 0x18, 0x3);
1189 /*BT select s0/s1 is controlled by BT */
1190 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x67, 0x20, 0x0);
1192 /* 0x4c[24:23]=00, Set Antenna control by BT_RFE_CTRL
1193 * BT Vendor 0xac=0xf002 */
1194 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
1197 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u32tmp
);
1200 if (use_ext_switch
) {
1202 /* 0x4c[23]=0, 0x4c[24]=1 Antenna control by WL/BT */
1203 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
1206 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u32tmp
);
1208 if (board_info
->btdm_ant_pos
==
1209 BTC_ANTENNA_AT_MAIN_PORT
) {
1210 /* Main Ant to BT for IPS case 0x4c[23]=1 */
1211 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1215 /*tell firmware "no antenna inverse"*/
1216 h2c_parameter
[0] = 0;
1217 h2c_parameter
[1] = 1; /*ext switch type*/
1218 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1221 /*Aux Ant to BT for IPS case 0x4c[23]=1 */
1222 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1226 /*tell firmware "antenna inverse"*/
1227 h2c_parameter
[0] = 1;
1228 h2c_parameter
[1] = 1; /*ext switch type*/
1229 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1234 /* fixed internal switch first*/
1235 /* fixed internal switch S1->WiFi, S0->BT*/
1236 if (board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
1237 btcoexist
->btc_write_2byte(btcoexist
, 0x948, 0x0);
1238 else/* fixed internal switch S0->WiFi, S1->BT*/
1239 btcoexist
->btc_write_2byte(btcoexist
, 0x948, 0x280);
1241 /* ext switch setting */
1242 switch (ant_pos_type
) {
1243 case BTC_ANT_PATH_WIFI
:
1244 if (board_info
->btdm_ant_pos
==
1245 BTC_ANTENNA_AT_MAIN_PORT
)
1246 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1250 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1254 case BTC_ANT_PATH_BT
:
1255 if (board_info
->btdm_ant_pos
==
1256 BTC_ANTENNA_AT_MAIN_PORT
)
1257 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1261 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1266 case BTC_ANT_PATH_PTA
:
1267 if (board_info
->btdm_ant_pos
==
1268 BTC_ANTENNA_AT_MAIN_PORT
)
1269 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1273 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1281 /* 0x4c[23]=1, 0x4c[24]=0 Antenna control by 0x64*/
1282 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
1285 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u32tmp
);
1287 if (board_info
->btdm_ant_pos
==
1288 BTC_ANTENNA_AT_MAIN_PORT
) {
1289 /*Main Ant to WiFi for IPS case 0x4c[23]=1*/
1290 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1294 /*tell firmware "no antenna inverse"*/
1295 h2c_parameter
[0] = 0;
1296 h2c_parameter
[1] = 0; /*internal switch type*/
1297 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1300 /*Aux Ant to BT for IPS case 0x4c[23]=1*/
1301 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1305 /*tell firmware "antenna inverse"*/
1306 h2c_parameter
[0] = 1;
1307 h2c_parameter
[1] = 0; /*internal switch type*/
1308 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1313 /* fixed external switch first*/
1314 /*Main->WiFi, Aux->BT*/
1315 if(board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
1316 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x92c,
1318 else/*Main->BT, Aux->WiFi */
1319 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x92c,
1322 /* internal switch setting*/
1323 switch (ant_pos_type
) {
1324 case BTC_ANT_PATH_WIFI
:
1325 if(board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
1326 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1329 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1332 case BTC_ANT_PATH_BT
:
1333 if(board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
1334 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1337 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1341 case BTC_ANT_PATH_PTA
:
1342 if(board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
1343 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1346 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1353 static void halbtc8723b1ant_ps_tdma(struct btc_coexist
*btcoexist
,
1354 bool force_exec
, bool turn_on
, u8 type
)
1356 bool wifi_busy
= false;
1357 u8 rssi_adjust_val
= 0;
1359 coex_dm
->cur_ps_tdma_on
= turn_on
;
1360 coex_dm
->cur_ps_tdma
= type
;
1362 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
1365 if (coex_dm
->cur_ps_tdma_on
)
1366 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1367 "[BTCoex], ******** TDMA(on, %d) *********\n",
1368 coex_dm
->cur_ps_tdma
);
1370 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1371 "[BTCoex], ******** TDMA(off, %d) ********\n",
1372 coex_dm
->cur_ps_tdma
);
1375 if ((coex_dm
->pre_ps_tdma_on
== coex_dm
->cur_ps_tdma_on
) &&
1376 (coex_dm
->pre_ps_tdma
== coex_dm
->cur_ps_tdma
))
1382 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x1a,
1387 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1391 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
,0x51,
1395 rssi_adjust_val
= 11;
1399 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1403 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1406 rssi_adjust_val
= 14;
1409 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x1d,
1413 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x15,
1415 rssi_adjust_val
= 17;
1418 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x15,
1422 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x20,
1426 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x13, 0xc,
1430 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x25,
1435 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1439 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1442 rssi_adjust_val
= 18;
1445 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x13, 0xa,
1450 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1454 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51,
1457 rssi_adjust_val
= 20;
1460 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x0a,
1464 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x15,
1468 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x21,
1472 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x13, 0xa,
1476 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x15,
1478 rssi_adjust_val
= 18;
1481 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x25,
1483 rssi_adjust_val
= 14;
1486 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x35,
1490 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x15,
1494 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x25,
1498 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0x25,
1500 rssi_adjust_val
= 22;
1503 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0x15,
1505 rssi_adjust_val
= 22;
1508 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0xa,
1510 rssi_adjust_val
= 22;
1513 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0xa,
1515 rssi_adjust_val
= 22;
1518 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0x25,
1520 rssi_adjust_val
= 22;
1523 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x69, 0x25,
1527 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xab, 0x1a,
1531 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x14,
1535 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xd3, 0x1a,
1539 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0xa,
1543 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xa3, 0x25,
1547 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x53, 0x1a,
1551 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x63, 0x1a,
1555 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xd3, 0x12,
1558 /* SoftAP only with no sta associated,BT disable ,
1559 * TDMA mode for power saving
1560 * here softap mode screen off will cost 70-80mA for phone */
1562 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x23, 0x18,
1568 case 8: /*PTA Control */
1569 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x8, 0x0,
1571 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_PTA
,
1575 default: /*Software control, Antenna at BT side */
1576 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x0, 0x0,
1578 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
,
1581 case 9: /*Software control, Antenna at WiFi side */
1582 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x0, 0x0,
1584 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_WIFI
,
1589 rssi_adjust_val
= 0;
1590 btcoexist
->btc_set(btcoexist
,
1591 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE
,
1594 /* update pre state */
1595 coex_dm
->pre_ps_tdma_on
= coex_dm
->cur_ps_tdma_on
;
1596 coex_dm
->pre_ps_tdma
= coex_dm
->cur_ps_tdma
;
1599 static bool halbtc8723b1ant_is_common_action(struct btc_coexist
*btcoexist
)
1601 bool commom
= false, wifi_connected
= false;
1602 bool wifi_busy
= false;
1604 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
1606 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
1608 if (!wifi_connected
&&
1609 BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
== coex_dm
->bt_status
) {
1610 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1611 "[BTCoex], Wifi non connected-idle + "
1612 "BT non connected-idle!!\n");
1613 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
1614 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
1616 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
1618 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
1622 } else if (wifi_connected
&&
1623 (BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
==
1624 coex_dm
->bt_status
)) {
1625 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1626 "[BTCoex], Wifi connected + "
1627 "BT non connected-idle!!\n");
1628 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
1629 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
1631 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
1633 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
1637 } else if (!wifi_connected
&&
1638 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
==
1639 coex_dm
->bt_status
)) {
1640 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1641 "[BTCoex], Wifi non connected-idle + "
1642 "BT connected-idle!!\n");
1643 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
1644 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
1646 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
1648 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
1652 } else if (wifi_connected
&&
1653 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
==
1654 coex_dm
->bt_status
)) {
1655 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1656 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1657 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
1658 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
1660 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
1662 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
1666 } else if (!wifi_connected
&&
1667 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
!=
1668 coex_dm
->bt_status
)) {
1669 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1670 ("[BTCoex], Wifi non connected-idle + BT Busy!!\n"));
1671 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
1672 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
1674 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
1676 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
1682 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1683 "[BTCoex], Wifi Connected-Busy"
1686 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1687 "[BTCoex], Wifi Connected-Idle"
1697 static void halbtc8723b1ant_tdma_duration_adjust_for_acl(
1698 struct btc_coexist
*btcoexist
,
1701 static s32 up
, dn
, m
, n
, wait_count
;
1702 /* 0: no change, +1: increase WiFi duration,
1703 * -1: decrease WiFi duration */
1705 u8 retry_count
= 0, bt_info_ext
;
1706 static bool pre_wifi_busy
= false;
1707 bool wifi_busy
= false;
1709 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
1710 "[BTCoex], TdmaDurationAdjustForAcl()\n");
1712 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
== wifi_status
)
1717 if ((BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN
==
1719 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
== wifi_status
) ||
1720 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT
== wifi_status
)) {
1721 if (coex_dm
->cur_ps_tdma
!= 1 && coex_dm
->cur_ps_tdma
!= 2 &&
1722 coex_dm
->cur_ps_tdma
!= 3 && coex_dm
->cur_ps_tdma
!= 9) {
1723 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1725 coex_dm
->ps_tdma_du_adj_type
= 9;
1737 if (!coex_dm
->auto_tdma_adjust
) {
1738 coex_dm
->auto_tdma_adjust
= true;
1739 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1740 "[BTCoex], first run TdmaDurationAdjust()!!\n");
1742 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 2);
1743 coex_dm
->ps_tdma_du_adj_type
= 2;
1752 /*acquire the BT TRx retry count from BT_Info byte2 */
1753 retry_count
= coex_sta
->bt_retry_cnt
;
1754 bt_info_ext
= coex_sta
->bt_info_ext
;
1757 /* no retry in the last 2-second duration */
1758 if (retry_count
== 0) {
1771 BTC_PRINT(BTC_MSG_ALGORITHM
,
1772 ALGO_TRACE_FW_DETAIL
,
1773 "[BTCoex], Increase wifi "
1776 } else if (retry_count
<= 3) {
1784 if (wait_count
<= 2)
1797 BTC_PRINT(BTC_MSG_ALGORITHM
,
1798 ALGO_TRACE_FW_DETAIL
,
1799 "[BTCoex], Decrease wifi duration"
1800 " for retryCounter<3!!\n");
1803 if (wait_count
== 1)
1816 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1817 "[BTCoex], Decrease wifi duration"
1818 " for retryCounter>3!!\n");
1822 if ((BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext
)) &&
1823 ((coex_dm
->cur_ps_tdma
== 1) ||
1824 (coex_dm
->cur_ps_tdma
== 2))) {
1825 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1827 coex_dm
->ps_tdma_du_adj_type
= 9;
1828 } else if (coex_dm
->cur_ps_tdma
== 1) {
1829 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1831 coex_dm
->ps_tdma_du_adj_type
= 2;
1832 } else if (coex_dm
->cur_ps_tdma
== 2) {
1833 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1835 coex_dm
->ps_tdma_du_adj_type
= 9;
1836 } else if (coex_dm
->cur_ps_tdma
== 9) {
1837 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1839 coex_dm
->ps_tdma_du_adj_type
= 11;
1841 } else if(result
== 1) {
1842 if ((BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext
)) &&
1843 ((coex_dm
->cur_ps_tdma
== 1) ||
1844 (coex_dm
->cur_ps_tdma
== 2))) {
1845 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1847 coex_dm
->ps_tdma_du_adj_type
= 9;
1848 } else if (coex_dm
->cur_ps_tdma
== 11) {
1849 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1851 coex_dm
->ps_tdma_du_adj_type
= 9;
1852 } else if (coex_dm
->cur_ps_tdma
== 9) {
1853 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1855 coex_dm
->ps_tdma_du_adj_type
= 2;
1856 } else if (coex_dm
->cur_ps_tdma
== 2) {
1857 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1859 coex_dm
->ps_tdma_du_adj_type
= 1;
1861 } else { /*no change */
1862 /*if busy / idle change */
1863 if (wifi_busy
!= pre_wifi_busy
) {
1864 pre_wifi_busy
= wifi_busy
;
1865 halbtc8723b1ant_ps_tdma(btcoexist
, FORCE_EXEC
,
1867 coex_dm
->cur_ps_tdma
);
1870 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
1871 "[BTCoex],********* TDMA(on, %d) ********\n",
1872 coex_dm
->cur_ps_tdma
);
1875 if (coex_dm
->cur_ps_tdma
!= 1 && coex_dm
->cur_ps_tdma
!= 2 &&
1876 coex_dm
->cur_ps_tdma
!= 9 && coex_dm
->cur_ps_tdma
!= 11) {
1877 /* recover to previous adjust type */
1878 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true,
1879 coex_dm
->ps_tdma_du_adj_type
);
1884 static void halbtc8723b1ant_PsTdmaCheckForPowerSaveState(
1885 struct btc_coexist
*btcoexist
, bool new_ps_state
)
1889 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_LPS_MODE
, &lps_mode
);
1891 if (lps_mode
) { /* already under LPS state */
1893 /* keep state under LPS, do nothing. */
1895 /* will leave LPS state, turn off psTdma first */
1896 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1899 } else { /* NO PS state */
1901 /* will enter LPS state, turn off psTdma first */
1902 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1905 /* keep state under NO PS state, do nothing. */
1910 static void halbtc8723b1ant_power_save_state(struct btc_coexist
*btcoexist
,
1911 u8 ps_type
, u8 lps_val
,
1914 bool low_pwr_disable
= false;
1917 case BTC_PS_WIFI_NATIVE
:
1918 /* recover to original 32k low power setting */
1919 low_pwr_disable
= false;
1920 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_DISABLE_LOW_POWER
,
1922 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_NORMAL_LPS
, NULL
);
1925 halbtc8723b1ant_PsTdmaCheckForPowerSaveState(btcoexist
, true);
1926 halbtc8723b1ant_LpsRpwm(btcoexist
, NORMAL_EXEC
, lps_val
,
1928 /* when coex force to enter LPS, do not enter 32k low power. */
1929 low_pwr_disable
= true;
1930 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_DISABLE_LOW_POWER
,
1932 /* power save must executed before psTdma. */
1933 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_ENTER_LPS
, NULL
);
1935 case BTC_PS_LPS_OFF
:
1936 halbtc8723b1ant_PsTdmaCheckForPowerSaveState(btcoexist
, false);
1937 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_LEAVE_LPS
, NULL
);
1944 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
1945 static void halbtc8723b1ant_action_wifi_only(struct btc_coexist
*btcoexist
)
1947 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
1948 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 9);
1951 static void halbtc8723b1ant_monitor_bt_enable_disable(
1952 struct btc_coexist
*btcoexist
)
1954 static bool pre_bt_disabled
= false;
1955 static u32 bt_disable_cnt
= 0;
1956 bool bt_active
= true, bt_disabled
= false;
1958 /* This function check if bt is disabled */
1960 if (coex_sta
->high_priority_tx
== 0 &&
1961 coex_sta
->high_priority_rx
== 0 &&
1962 coex_sta
->low_priority_tx
== 0 &&
1963 coex_sta
->low_priority_rx
== 0)
1966 if (coex_sta
->high_priority_tx
== 0xffff &&
1967 coex_sta
->high_priority_rx
== 0xffff &&
1968 coex_sta
->low_priority_tx
== 0xffff &&
1969 coex_sta
->low_priority_rx
== 0xffff)
1974 bt_disabled
= false;
1975 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_DISABLE
,
1977 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1978 "[BTCoex], BT is enabled !!\n");
1981 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1982 "[BTCoex], bt all counters=0, %d times!!\n",
1984 if (bt_disable_cnt
>= 2) {
1986 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_DISABLE
,
1988 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1989 "[BTCoex], BT is disabled !!\n");
1990 halbtc8723b1ant_action_wifi_only(btcoexist
);
1993 if (pre_bt_disabled
!= bt_disabled
) {
1994 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1995 "[BTCoex], BT is from %s to %s!!\n",
1996 (pre_bt_disabled
? "disabled" : "enabled"),
1997 (bt_disabled
? "disabled" : "enabled"));
1998 pre_bt_disabled
= bt_disabled
;
2001 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_LEAVE_LPS
,
2003 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_NORMAL_LPS
,
2010 /***************************************************
2012 * Software Coex Mechanism start
2014 ***************************************************/
2015 /* SCO only or SCO+PAN(HS) */
2016 static void halbtc8723b1ant_action_sco(struct btc_coexist
*btcoexist
)
2022 halbtc8723b1ant_wifi_rssi_state(btcoexist
, 0, 2, 25, 0);
2024 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 4);
2026 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2027 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2029 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2031 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2033 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2035 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2036 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2037 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2039 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2042 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2044 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2049 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2050 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2051 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2053 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2056 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2058 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2065 static void halbtc8723b1ant_action_hid(struct btc_coexist
*btcoexist
)
2067 u8 wifi_rssi_state
, bt_rssi_state
;
2070 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2072 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2074 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2076 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2077 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2079 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2081 btcoexist
->btc_get(btcoexist
,
2082 BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2084 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2086 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2087 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2088 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2090 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2093 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2095 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2100 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2101 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2102 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2104 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2107 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2109 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2115 /*A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2116 static void halbtc8723b1ant_action_a2dp(struct btc_coexist
*btcoexist
)
2118 u8 wifi_rssi_state
, bt_rssi_state
;
2121 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2123 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2125 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2127 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2128 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2130 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2132 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2134 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2136 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2137 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2138 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2140 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2143 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2145 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2150 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2151 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2152 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2154 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2157 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2159 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2165 static void halbtc8723b1ant_action_a2dp_pan_hs(struct btc_coexist
*btcoexist
)
2167 u8 wifi_rssi_state
, bt_rssi_state
, bt_info_ext
;
2170 bt_info_ext
= coex_sta
->bt_info_ext
;
2171 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2173 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2175 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2177 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2178 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2180 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2182 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2184 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2186 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2187 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2188 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2190 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2193 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2195 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2200 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2201 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2202 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2204 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2207 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2209 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2215 static void halbtc8723b1ant_action_pan_edr(struct btc_coexist
*btcoexist
)
2217 u8 wifi_rssi_state
, bt_rssi_state
;
2220 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2222 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2224 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2226 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2227 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2229 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2231 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2233 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2235 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2236 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2237 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2239 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2242 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2244 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2249 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2250 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2251 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2253 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2256 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2258 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2266 static void halbtc8723b1ant_action_pan_hs(struct btc_coexist
*btcoexist
)
2268 u8 wifi_rssi_state
, bt_rssi_state
;
2271 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2273 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2275 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2277 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2279 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2281 if((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2282 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
))
2283 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
,
2286 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
,
2290 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2291 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2292 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2294 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2297 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2299 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2304 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2305 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
))
2306 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
,
2309 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
,
2313 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2314 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2315 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2317 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2320 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2322 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2329 static void halbtc8723b1ant_action_pan_edr_a2dp(struct btc_coexist
*btcoexist
)
2331 u8 wifi_rssi_state
, bt_rssi_state
, bt_info_ext
;
2334 bt_info_ext
= coex_sta
->bt_info_ext
;
2335 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2337 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2339 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2341 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2342 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2344 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2346 btcoexist
->btc_get(btcoexist
,
2347 BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2349 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2351 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2352 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2353 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2355 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2358 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2360 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2365 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2366 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2367 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2369 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2372 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false,
2374 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2380 static void halbtc8723b1ant_action_pan_edr_hid(struct btc_coexist
*btcoexist
)
2382 u8 wifi_rssi_state
, bt_rssi_state
;
2385 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2387 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2389 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2391 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2392 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2394 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2396 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2398 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2400 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2401 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2402 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2404 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2407 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2409 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2414 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2415 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2416 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2418 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2421 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2423 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2429 /* HID+A2DP+PAN(EDR) */
2430 static void halbtc8723b1ant_action_hid_a2dp_pan_edr(
2431 struct btc_coexist
*btcoexist
)
2433 u8 wifi_rssi_state
, bt_rssi_state
, bt_info_ext
;
2436 bt_info_ext
= coex_sta
->bt_info_ext
;
2437 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2439 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2441 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, NORMAL_EXEC
, 6);
2443 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2444 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2446 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2448 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2450 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2452 if((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2453 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2454 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2456 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2459 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2461 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2466 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2467 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2468 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2470 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2473 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2475 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2481 static void halbtc8723b1ant_action_hid_a2dp(struct btc_coexist
*btcoexist
)
2483 u8 wifi_rssi_state
, bt_rssi_state
, bt_info_ext
;
2486 bt_info_ext
= coex_sta
->bt_info_ext
;
2487 wifi_rssi_state
= halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2489 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 50, 0);
2491 if (halbtc8723b1ant_need_to_dec_bt_pwr(btcoexist
))
2492 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2494 halbtc8723b1ant_dec_bt_pwr(btcoexist
, NORMAL_EXEC
, false);
2496 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2498 if (BTC_WIFI_BW_HT40
== wifi_bw
) {
2500 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2501 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2502 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2504 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2507 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2509 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2514 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2515 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2516 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2518 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2521 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, true,
2523 halbtc8723b1ant_sw_mechanism2(btcoexist
, false, false,
2529 /*****************************************************
2531 * Non-Software Coex Mechanism start
2533 *****************************************************/
2534 static void halbtc8723b1ant_action_hs(struct btc_coexist
*btcoexist
)
2536 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
2537 halbtc8723b1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 2);
2540 static void halbtc8723b1ant_action_bt_inquiry(struct btc_coexist
*btcoexist
)
2542 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2543 bool wifi_connected
= false, ap_enable
= false;
2545 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_AP_MODE_ENABLE
,
2547 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2550 if (!wifi_connected
) {
2551 halbtc8723b1ant_power_save_state(btcoexist
,
2552 BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
2553 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
2554 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2555 } else if (bt_link_info
->sco_exist
|| bt_link_info
->hid_only
) {
2556 /* SCO/HID-only busy */
2557 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2559 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 32);
2560 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2563 halbtc8723b1ant_power_save_state(btcoexist
,
2567 halbtc8723b1ant_power_save_state(btcoexist
,
2571 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 30);
2572 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2576 static void halbtc8723b1ant_action_bt_sco_hid_only_busy(
2577 struct btc_coexist
*btcoexist
,
2580 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2581 bool wifi_connected
= false;
2583 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2586 /* tdma and coex table */
2588 if (bt_link_info
->sco_exist
) {
2589 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
2590 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
2592 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 6);
2593 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 5);
2597 static void halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2598 struct btc_coexist
*btcoexist
,
2603 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2604 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 28, 0);
2606 if (bt_link_info
->hid_only
) { /*HID */
2607 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist
,
2609 coex_dm
->auto_tdma_adjust
= false;
2611 } else if (bt_link_info
->a2dp_only
) { /*A2DP */
2612 if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2613 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2614 halbtc8723b1ant_tdma_duration_adjust_for_acl(btcoexist
,
2616 } else { /*for low BT RSSI */
2617 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2619 coex_dm
->auto_tdma_adjust
= false;
2622 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2623 } else if (bt_link_info
->hid_exist
&&
2624 bt_link_info
->a2dp_exist
) { /*HID+A2DP */
2625 if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2626 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2627 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2629 coex_dm
->auto_tdma_adjust
= false;
2630 } else { /*for low BT RSSI*/
2631 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2633 coex_dm
->auto_tdma_adjust
= false;
2636 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 6);
2637 /*PAN(OPP,FTP), HID+PAN(OPP,FTP) */
2638 } else if (bt_link_info
->pan_only
||
2639 (bt_link_info
->hid_exist
&& bt_link_info
->pan_exist
)) {
2640 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 3);
2641 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 6);
2642 coex_dm
->auto_tdma_adjust
= false;
2643 /*A2DP+PAN(OPP,FTP), HID+A2DP+PAN(OPP,FTP)*/
2644 } else if ((bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) ||
2645 (bt_link_info
->hid_exist
&& bt_link_info
->a2dp_exist
&&
2646 bt_link_info
->pan_exist
)) {
2647 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 13);
2648 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2649 coex_dm
->auto_tdma_adjust
= false;
2651 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 11);
2652 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2653 coex_dm
->auto_tdma_adjust
= false;
2657 static void halbtc8723b1ant_action_wifi_not_connected(
2658 struct btc_coexist
*btcoexist
)
2660 /* power save state */
2661 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2664 /* tdma and coex table */
2665 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
2666 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
2669 static void halbtc8723b1ant_action_wifi_not_connected_asso_auth_scan(
2670 struct btc_coexist
*btcoexist
)
2672 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2675 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 22);
2676 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2679 static void halbtc8723b1ant_ActionWifiConnectedScan(
2680 struct btc_coexist
*btcoexist
)
2682 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2684 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2687 /* tdma and coex table */
2688 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
2689 if (bt_link_info
->a2dp_exist
&&
2690 bt_link_info
->pan_exist
) {
2691 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2693 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2696 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
2697 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2699 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
2700 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
2701 coex_dm
->bt_status
)) {
2702 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist
,
2703 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
);
2705 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
2706 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2710 static void halbtc8723b1ant_action_wifi_connected_special_packet(
2711 struct btc_coexist
*btcoexist
)
2713 bool hs_connecting
= false;
2714 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2716 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_CONNECTING
, &hs_connecting
);
2718 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2721 /* tdma and coex table */
2722 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
2723 if (bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) {
2724 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2726 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2729 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2731 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2735 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
2736 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
2740 static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist
*btcoexist
)
2742 bool wifi_busy
= false;
2743 bool scan
= false, link
= false, roam
= false;
2744 bool under_4way
= false, ap_enable
= false;
2746 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2747 "[BTCoex], CoexForWifiConnect()===>\n");
2749 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_4_WAY_PROGRESS
,
2752 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist
);
2753 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2754 "[BTCoex], CoexForWifiConnect(), "
2755 "return for wifi is under 4way<===\n");
2759 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
2760 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
2761 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
2763 if (scan
|| link
|| roam
) {
2764 halbtc8723b1ant_ActionWifiConnectedScan(btcoexist
);
2765 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2766 "[BTCoex], CoexForWifiConnect(), "
2767 "return for wifi is under scan<===\n");
2771 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_AP_MODE_ENABLE
,
2773 /* power save state */
2775 BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
&&
2776 !btcoexist
->bt_link_info
.hid_only
)
2777 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_LPS_ON
,
2780 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2783 /* tdma and coex table */
2784 btcoexist
->btc_get(btcoexist
,
2785 BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
2787 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
2788 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(btcoexist
,
2789 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
2790 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
==
2791 coex_dm
->bt_status
) ||
2792 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
2793 coex_dm
->bt_status
)) {
2794 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist
,
2795 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
2797 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2799 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2803 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
2804 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(btcoexist
,
2805 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
2806 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
==
2807 coex_dm
->bt_status
) ||
2808 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
2809 coex_dm
->bt_status
)) {
2810 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist
,
2811 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
2813 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
2814 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2820 static void halbtc8723b1ant_run_sw_coexist_mechanism(
2821 struct btc_coexist
*btcoexist
)
2825 algorithm
= halbtc8723b1ant_action_algorithm(btcoexist
);
2826 coex_dm
->cur_algorithm
= algorithm
;
2828 if (halbtc8723b1ant_is_common_action(btcoexist
)) {
2830 switch (coex_dm
->cur_algorithm
) {
2831 case BT_8723B_1ANT_COEX_ALGO_SCO
:
2832 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2833 "[BTCoex], Action algorithm = SCO.\n");
2834 halbtc8723b1ant_action_sco(btcoexist
);
2836 case BT_8723B_1ANT_COEX_ALGO_HID
:
2837 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2838 "[BTCoex], Action algorithm = HID.\n");
2839 halbtc8723b1ant_action_hid(btcoexist
);
2841 case BT_8723B_1ANT_COEX_ALGO_A2DP
:
2842 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2843 "[BTCoex], Action algorithm = A2DP.\n");
2844 halbtc8723b1ant_action_a2dp(btcoexist
);
2846 case BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS
:
2847 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2848 "[BTCoex], Action algorithm = "
2850 halbtc8723b1ant_action_a2dp_pan_hs(btcoexist
);
2852 case BT_8723B_1ANT_COEX_ALGO_PANEDR
:
2853 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2854 "[BTCoex], Action algorithm = PAN(EDR).\n");
2855 halbtc8723b1ant_action_pan_edr(btcoexist
);
2857 case BT_8723B_1ANT_COEX_ALGO_PANHS
:
2858 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2859 "[BTCoex], Action algorithm = HS mode.\n");
2860 halbtc8723b1ant_action_pan_hs(btcoexist
);
2862 case BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP
:
2863 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2864 "[BTCoex], Action algorithm = PAN+A2DP.\n");
2865 halbtc8723b1ant_action_pan_edr_a2dp(btcoexist
);
2867 case BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
:
2868 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2869 "[BTCoex], Action algorithm = "
2871 halbtc8723b1ant_action_pan_edr_hid(btcoexist
);
2873 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR
:
2874 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2875 "[BTCoex], Action algorithm = "
2877 halbtc8723b1ant_action_hid_a2dp_pan_edr(btcoexist
);
2879 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP
:
2880 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2881 "[BTCoex], Action algorithm = HID+A2DP.\n");
2882 halbtc8723b1ant_action_hid_a2dp(btcoexist
);
2885 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2886 "[BTCoex], Action algorithm = "
2887 "coexist All Off!!\n");
2890 coex_dm
->pre_algorithm
= coex_dm
->cur_algorithm
;
2894 static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist
*btcoexist
)
2896 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2897 bool wifi_connected
= false, bt_hs_on
= false;
2898 bool limited_dig
= false, bIncreaseScanDevNum
= false;
2899 bool b_bt_ctrl_agg_buf_size
= false;
2900 u8 agg_buf_size
= 5;
2901 u8 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
2903 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2904 "[BTCoex], RunCoexistMechanism()===>\n");
2906 if (btcoexist
->manual_control
) {
2907 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2908 "[BTCoex], RunCoexistMechanism(), "
2909 "return for Manual CTRL <===\n");
2913 if (btcoexist
->stop_coex_dm
) {
2914 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2915 "[BTCoex], RunCoexistMechanism(), "
2916 "return for Stop Coex DM <===\n");
2920 if (coex_sta
->under_ips
) {
2921 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2922 "[BTCoex], wifi is under IPS !!!\n");
2926 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) ||
2927 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
2928 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
)) {
2930 bIncreaseScanDevNum
= true;
2933 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_LIMITED_DIG
, &limited_dig
);
2934 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_INC_SCAN_DEV_NUM
,
2935 &bIncreaseScanDevNum
);
2937 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2940 if (!bt_link_info
->sco_exist
&& !bt_link_info
->hid_exist
) {
2941 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
2943 if (wifi_connected
) {
2945 halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2947 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2948 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2949 halbtc8723b1ant_limited_tx(btcoexist
,
2953 halbtc8723b1ant_limited_tx(btcoexist
,
2958 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
,
2963 if (bt_link_info
->sco_exist
) {
2964 b_bt_ctrl_agg_buf_size
= true;
2966 } else if (bt_link_info
->hid_exist
) {
2967 b_bt_ctrl_agg_buf_size
= true;
2969 } else if (bt_link_info
->a2dp_exist
|| bt_link_info
->pan_exist
) {
2970 b_bt_ctrl_agg_buf_size
= true;
2973 halbtc8723b1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
2974 b_bt_ctrl_agg_buf_size
, agg_buf_size
);
2976 halbtc8723b1ant_run_sw_coexist_mechanism(btcoexist
);
2978 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2980 if (coex_sta
->c2h_bt_inquiry_page
) {
2981 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
2983 } else if (bt_hs_on
) {
2984 halbtc8723b1ant_action_hs(btcoexist
);
2989 if (!wifi_connected
) {
2990 bool scan
= false, link
= false, roam
= false;
2992 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2993 "[BTCoex], wifi is non connected-idle !!!\n");
2995 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
2996 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
2997 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
2999 if (scan
|| link
|| roam
)
3000 halbtc8723b1ant_action_wifi_not_connected_asso_auth_scan(btcoexist
);
3002 halbtc8723b1ant_action_wifi_not_connected(btcoexist
);
3003 } else { /* wifi LPS/Busy */
3004 halbtc8723b1ant_action_wifi_connected(btcoexist
);
3008 static void halbtc8723b1ant_init_coex_dm(struct btc_coexist
*btcoexist
)
3010 /* force to reset coex mechanism */
3011 halbtc8723b1ant_fw_dac_swing_lvl(btcoexist
, FORCE_EXEC
, 6);
3012 halbtc8723b1ant_dec_bt_pwr(btcoexist
, FORCE_EXEC
, false);
3015 halbtc8723b1ant_sw_mechanism1(btcoexist
, false, false, false, false);
3016 halbtc8723b1ant_sw_mechanism2(btcoexist
,false, false, false, 0x18);
3018 halbtc8723b1ant_ps_tdma(btcoexist
, FORCE_EXEC
, false, 8);
3019 halbtc8723b1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 0);
3022 static void halbtc8723b1ant_init_hw_config(struct btc_coexist
*btcoexist
,
3027 u32 cnt_bt_cal_chk
= 0;
3029 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3030 "[BTCoex], 1Ant Init HW Config!!\n");
3032 if (backup
) {/* backup rf 0x1e value */
3033 coex_dm
->bt_rf0x1e_backup
=
3034 btcoexist
->btc_get_rf_reg(btcoexist
,
3035 BTC_RF_A
, 0x1e, 0xfffff);
3037 coex_dm
->backup_arfr_cnt1
=
3038 btcoexist
->btc_read_4byte(btcoexist
, 0x430);
3039 coex_dm
->backup_arfr_cnt2
=
3040 btcoexist
->btc_read_4byte(btcoexist
, 0x434);
3041 coex_dm
->backup_retry_limit
=
3042 btcoexist
->btc_read_2byte(btcoexist
, 0x42a);
3043 coex_dm
->backup_ampdu_max_time
=
3044 btcoexist
->btc_read_1byte(btcoexist
, 0x456);
3047 /* WiFi goto standby while GNT_BT 0-->1 */
3048 btcoexist
->btc_set_rf_reg(btcoexist
, BTC_RF_A
, 0x1, 0xfffff, 0x780);
3049 /* BT goto standby while GNT_BT 1-->0 */
3050 btcoexist
->btc_set_rf_reg(btcoexist
, BTC_RF_A
, 0x2, 0xfffff, 0x500);
3052 btcoexist
->btc_write_1byte(btcoexist
, 0x974, 0xff);
3053 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x944, 0x3, 0x3);
3054 btcoexist
->btc_write_1byte(btcoexist
, 0x930, 0x77);
3057 /* BT calibration check */
3058 while (cnt_bt_cal_chk
<= 20) {
3059 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x49d);
3061 if (u32tmp
& BIT0
) {
3062 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3063 "[BTCoex], ########### BT "
3064 "calibration(cnt=%d) ###########\n",
3068 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3069 "[BTCoex], ********** BT NOT "
3070 "calibration (cnt=%d)**********\n",
3076 /* 0x790[5:0]=0x5 */
3077 u8tmp
= btcoexist
->btc_read_1byte(btcoexist
, 0x790);
3080 btcoexist
->btc_write_1byte(btcoexist
, 0x790, u8tmp
);
3082 /* Enable counter statistics */
3083 /*0x76e[3] =1, WLAN_Act control by PTA */
3084 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0xc);
3085 btcoexist
->btc_write_1byte(btcoexist
, 0x778, 0x1);
3086 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x40, 0x20, 0x1);
3089 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_PTA
, true, false);
3091 halbtc8723b1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 0);
3095 static void halbtc8723b1ant_wifi_off_hw_cfg(struct btc_coexist
*btcoexist
)
3097 /* set wlan_act to low */
3098 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0);
3101 /**************************************************************
3102 * work around function start with wa_halbtc8723b1ant_
3103 **************************************************************/
3104 /**************************************************************
3105 * extern function start with EXhalbtc8723b1ant_
3106 **************************************************************/
3108 void ex_halbtc8723b1ant_init_hwconfig(struct btc_coexist
*btcoexist
)
3110 halbtc8723b1ant_init_hw_config(btcoexist
, true);
3113 void ex_halbtc8723b1ant_init_coex_dm(struct btc_coexist
*btcoexist
)
3115 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3116 "[BTCoex], Coex Mechanism Init!!\n");
3118 btcoexist
->stop_coex_dm
= false;
3120 halbtc8723b1ant_init_coex_dm(btcoexist
);
3122 halbtc8723b1ant_query_bt_info(btcoexist
);
3125 void ex_halbtc8723b1ant_display_coex_info(struct btc_coexist
*btcoexist
)
3127 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
3128 struct btc_stack_info
*stack_info
= &btcoexist
->stack_info
;
3129 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
3130 u8
*cli_buf
= btcoexist
->cli_buf
;
3131 u8 u8tmp
[4], i
, bt_info_ext
, psTdmaCase
=0;
3134 bool roam
= false, scan
= false;
3135 bool link
= false, wifi_under_5g
= false;
3136 bool bt_hs_on
= false, wifi_busy
= false;
3137 s32 wifi_rssi
=0, bt_hs_rssi
= 0;
3138 u32 wifi_bw
, wifi_traffic_dir
, fa_ofdm
, fa_cck
;
3139 u8 wifi_dot11_chnl
, wifi_hs_chnl
;
3140 u32 fw_ver
= 0, bt_patch_ver
= 0;
3142 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3143 "\r\n ============[BT Coexist info]============");
3146 if (btcoexist
->manual_control
) {
3147 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3148 "\r\n ============[Under Manual Control]==========");
3150 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3151 "\r\n ==========================================");
3154 if (btcoexist
->stop_coex_dm
) {
3155 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3156 "\r\n ============[Coex is STOPPED]============");
3158 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3159 "\r\n ==========================================");
3163 if (!board_info
->bt_exist
) {
3164 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n BT not exists !!!");
3169 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d/ %d",
3170 "Ant PG Num/ Ant Mech/ Ant Pos:", \
3171 board_info
->pg_ant_num
, board_info
->btdm_ant_num
,
3172 board_info
->btdm_ant_pos
);
3175 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %s / %d",
3176 "BT stack/ hci ext ver", \
3177 ((stack_info
->profile_notified
)? "Yes":"No"),
3178 stack_info
->hci_version
);
3181 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_BT_PATCH_VER
, &bt_patch_ver
);
3182 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
3183 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3184 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3185 "CoexVer/ FwVer/ PatchVer", \
3186 glcoex_ver_date_8723b_1ant
, glcoex_ver_8723b_1ant
,
3187 fw_ver
, bt_patch_ver
, bt_patch_ver
);
3190 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
3191 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_DOT11_CHNL
,
3193 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_HS_CHNL
, &wifi_hs_chnl
);
3194 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d / %d(%d)",
3195 "Dot11 channel / HsChnl(HsMode)", \
3196 wifi_dot11_chnl
, wifi_hs_chnl
, bt_hs_on
);
3199 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %02x %02x %02x ",
3200 "H2C Wifi inform bt chnl Info", \
3201 coex_dm
->wifi_chnl_info
[0], coex_dm
->wifi_chnl_info
[1],
3202 coex_dm
->wifi_chnl_info
[2]);
3205 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_WIFI_RSSI
, &wifi_rssi
);
3206 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_HS_RSSI
, &bt_hs_rssi
);
3207 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d",
3208 "Wifi rssi/ HS rssi", wifi_rssi
, bt_hs_rssi
);
3211 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
3212 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
3213 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
3214 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d/ %d ",
3215 "Wifi link/ roam/ scan", link
, roam
, scan
);
3218 btcoexist
->btc_get(btcoexist
,BTC_GET_BL_WIFI_UNDER_5G
,
3220 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
3221 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
3222 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION
,
3225 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %s / %s/ %s ",
3226 "Wifi status", (wifi_under_5g
? "5G":"2.4G"),
3227 ((BTC_WIFI_BW_LEGACY
==wifi_bw
)? "Legacy":
3228 (((BTC_WIFI_BW_HT40
==wifi_bw
)? "HT40":"HT20"))),
3229 ((!wifi_busy
)? "idle":
3230 ((BTC_WIFI_TRAFFIC_TX
==wifi_traffic_dir
)?
3231 "uplink":"downlink")));
3233 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = [%s/ %d/ %d] ",
3234 "BT [status/ rssi/ retryCnt]",
3235 ((btcoexist
->bt_info
.bt_disabled
)? ("disabled"):
3236 ((coex_sta
->c2h_bt_inquiry_page
)?("inquiry/page scan"):
3237 ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
== coex_dm
->bt_status
)?
3238 "non-connected idle":
3239 ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
== coex_dm
->bt_status
)?
3240 "connected-idle":"busy")))),
3241 coex_sta
->bt_rssi
, coex_sta
->bt_retry_cnt
);
3245 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d / %d / %d / %d",
3246 "SCO/HID/PAN/A2DP", bt_link_info
->sco_exist
,
3247 bt_link_info
->hid_exist
, bt_link_info
->pan_exist
,
3248 bt_link_info
->a2dp_exist
);
3250 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_BT_LINK_INFO
);
3252 bt_info_ext
= coex_sta
->bt_info_ext
;
3253 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %s",
3254 "BT Info A2DP rate",
3255 (bt_info_ext
& BIT0
) ? "Basic rate" : "EDR rate");
3258 for (i
= 0; i
< BT_INFO_SRC_8723B_1ANT_MAX
; i
++) {
3259 if (coex_sta
->bt_info_c2h_cnt
[i
]) {
3260 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3261 "\r\n %-35s = %02x %02x %02x "
3262 "%02x %02x %02x %02x(%d)",
3263 GLBtInfoSrc8723b1Ant
[i
],
3264 coex_sta
->bt_info_c2h
[i
][0],
3265 coex_sta
->bt_info_c2h
[i
][1],
3266 coex_sta
->bt_info_c2h
[i
][2],
3267 coex_sta
->bt_info_c2h
[i
][3],
3268 coex_sta
->bt_info_c2h
[i
][4],
3269 coex_sta
->bt_info_c2h
[i
][5],
3270 coex_sta
->bt_info_c2h
[i
][6],
3271 coex_sta
->bt_info_c2h_cnt
[i
]);
3275 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3276 "\r\n %-35s = %s/%s, (0x%x/0x%x)",
3277 "PS state, IPS/LPS, (lps/rpwm)", \
3278 ((coex_sta
->under_ips
? "IPS ON":"IPS OFF")),
3279 ((coex_sta
->under_lps
? "LPS ON":"LPS OFF")),
3280 btcoexist
->bt_info
.lps_1ant
,
3281 btcoexist
->bt_info
.rpwm_1ant
);
3283 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_FW_PWR_MODE_CMD
);
3285 if (!btcoexist
->manual_control
) {
3287 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s",
3288 "============[Sw mechanism]============");
3291 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d/ %d ",
3292 "SM1[ShRf/ LpRA/ LimDig]", \
3293 coex_dm
->cur_rf_rx_lpf_shrink
,
3294 coex_dm
->cur_low_penalty_ra
,
3295 btcoexist
->bt_info
.limited_dig
);
3297 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3298 "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3299 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]", \
3300 coex_dm
->cur_agc_table_en
,
3301 coex_dm
->cur_adc_backoff
,
3302 coex_dm
->cur_dac_swing_on
,
3303 coex_dm
->cur_dac_swing_lvl
);
3308 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x ",
3309 "Rate Mask", btcoexist
->bt_info
.ra_mask
);
3313 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s",
3314 "============[Fw mechanism]============");
3317 psTdmaCase
= coex_dm
->cur_ps_tdma
;
3318 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3319 "\r\n %-35s = %02x %02x %02x %02x %02x "
3320 "case-%d (auto:%d)",
3321 "PS TDMA", coex_dm
->ps_tdma_para
[0],
3322 coex_dm
->ps_tdma_para
[1], coex_dm
->ps_tdma_para
[2],
3323 coex_dm
->ps_tdma_para
[3], coex_dm
->ps_tdma_para
[4],
3324 psTdmaCase
, coex_dm
->auto_tdma_adjust
);
3327 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x ",
3328 "Latest error condition(should be 0)", \
3329 coex_dm
->error_condition
);
3332 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d ",
3333 "DecBtPwr/ IgnWlanAct", coex_dm
->cur_dec_bt_pwr
,
3334 coex_dm
->cur_ignore_wlan_act
);
3339 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s",
3340 "============[Hw setting]============");
3343 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x",
3344 "RF-A, 0x1e initVal", coex_dm
->bt_rf0x1e_backup
);
3346 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
3347 "backup ARFR1/ARFR2/RL/AMaxTime", coex_dm
->backup_arfr_cnt1
,
3348 coex_dm
->backup_arfr_cnt2
, coex_dm
->backup_retry_limit
,
3349 coex_dm
->backup_ampdu_max_time
);
3352 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x430);
3353 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x434);
3354 u16tmp
[0] = btcoexist
->btc_read_2byte(btcoexist
, 0x42a);
3355 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x456);
3356 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
3357 "0x430/0x434/0x42a/0x456",
3358 u32tmp
[0], u32tmp
[1], u16tmp
[0], u8tmp
[0]);
3361 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x778);
3362 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x6cc);
3363 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x880);
3364 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3365 "0x778/0x6cc/0x880[29:25]", u8tmp
[0], u32tmp
[0],
3366 (u32tmp
[1] & 0x3e000000) >> 25);
3369 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x948);
3370 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x67);
3371 u8tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0x765);
3372 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3373 "0x948/ 0x67[5] / 0x765",
3374 u32tmp
[0], ((u8tmp
[0] & 0x20)>> 5), u8tmp
[1]);
3377 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x92c);
3378 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x930);
3379 u32tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0x944);
3380 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3381 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3382 u32tmp
[0] & 0x3, u32tmp
[1] & 0xff, u32tmp
[2] & 0x3);
3385 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x39);
3386 u8tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0x40);
3387 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
3388 u8tmp
[2] = btcoexist
->btc_read_1byte(btcoexist
, 0x64);
3389 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
3390 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3391 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3392 ((u8tmp
[0] & 0x8)>>3), u8tmp
[1],
3393 ((u32tmp
[0] & 0x01800000) >> 23), u8tmp
[2] & 0x1);
3396 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x550);
3397 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x522);
3398 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x",
3399 "0x550(bcn ctrl)/0x522", u32tmp
[0], u8tmp
[0]);
3402 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xc50);
3403 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x49c);
3404 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x",
3405 "0xc50(dig)/0x49c(null-drop)", u32tmp
[0] & 0xff, u8tmp
[0]);
3408 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xda0);
3409 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0xda4);
3410 u32tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0xda8);
3411 u32tmp
[3] = btcoexist
->btc_read_4byte(btcoexist
, 0xcf0);
3413 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0xa5b);
3414 u8tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0xa5c);
3416 fa_ofdm
= ((u32tmp
[0] & 0xffff0000) >> 16) +
3417 ((u32tmp
[1] & 0xffff0000) >> 16) +
3418 (u32tmp
[1] & 0xffff) +
3419 (u32tmp
[2] & 0xffff) + \
3420 ((u32tmp
[3] & 0xffff0000) >> 16) +
3421 (u32tmp
[3] & 0xffff) ;
3422 fa_cck
= (u8tmp
[0] << 8) + u8tmp
[1];
3424 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3425 "OFDM-CCA/OFDM-FA/CCK-FA",
3426 u32tmp
[0] & 0xffff, fa_ofdm
, fa_cck
);
3429 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c0);
3430 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c4);
3431 u32tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c8);
3432 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3433 "0x6c0/0x6c4/0x6c8(coexTable)",
3434 u32tmp
[0], u32tmp
[1], u32tmp
[2]);
3437 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d",
3438 "0x770(high-pri rx/tx)", coex_sta
->high_priority_rx
,
3439 coex_sta
->high_priority_tx
);
3441 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\r\n %-35s = %d/ %d",
3442 "0x774(low-pri rx/tx)", coex_sta
->low_priority_rx
,
3443 coex_sta
->low_priority_tx
);
3445 #if(BT_AUTO_REPORT_ONLY_8723B_1ANT == 1)
3446 halbtc8723b1ant_monitor_bt_ctr(btcoexist
);
3448 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_COEX_STATISTICS
);
3452 void ex_halbtc8723b1ant_ips_notify(struct btc_coexist
*btcoexist
, u8 type
)
3455 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
)
3458 if (BTC_IPS_ENTER
== type
) {
3459 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3460 "[BTCoex], IPS ENTER notify\n");
3461 coex_sta
->under_ips
= true;
3463 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
,
3465 /* set PTA control */
3466 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 0);
3467 halbtc8723b1ant_coex_table_with_type(btcoexist
,
3469 } else if (BTC_IPS_LEAVE
== type
) {
3470 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3471 "[BTCoex], IPS LEAVE notify\n");
3472 coex_sta
->under_ips
= false;
3474 halbtc8723b1ant_run_coexist_mechanism(btcoexist
);
3478 void ex_halbtc8723b1ant_lps_notify(struct btc_coexist
*btcoexist
, u8 type
)
3480 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
)
3483 if (BTC_LPS_ENABLE
== type
) {
3484 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3485 "[BTCoex], LPS ENABLE notify\n");
3486 coex_sta
->under_lps
= true;
3487 } else if (BTC_LPS_DISABLE
== type
) {
3488 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3489 "[BTCoex], LPS DISABLE notify\n");
3490 coex_sta
->under_lps
= false;
3494 void ex_halbtc8723b1ant_scan_notify(struct btc_coexist
*btcoexist
, u8 type
)
3496 bool wifi_connected
= false, bt_hs_on
= false;
3498 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
3499 btcoexist
->bt_info
.bt_disabled
)
3502 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
3503 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
3506 halbtc8723b1ant_query_bt_info(btcoexist
);
3508 if (coex_sta
->c2h_bt_inquiry_page
) {
3509 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
3511 } else if (bt_hs_on
) {
3512 halbtc8723b1ant_action_hs(btcoexist
);
3516 if (BTC_SCAN_START
== type
) {
3517 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3518 "[BTCoex], SCAN START notify\n");
3519 if (!wifi_connected
) /* non-connected scan */
3520 halbtc8723b1ant_action_wifi_not_connected_asso_auth_scan(btcoexist
);
3521 else /* wifi is connected */
3522 halbtc8723b1ant_ActionWifiConnectedScan(btcoexist
);
3523 } else if (BTC_SCAN_FINISH
== type
) {
3524 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3525 "[BTCoex], SCAN FINISH notify\n");
3526 if (!wifi_connected
) /* non-connected scan */
3527 halbtc8723b1ant_action_wifi_not_connected(btcoexist
);
3529 halbtc8723b1ant_action_wifi_connected(btcoexist
);
3533 void ex_halbtc8723b1ant_connect_notify(struct btc_coexist
*btcoexist
, u8 type
)
3535 bool wifi_connected
= false, bt_hs_on
= false;
3537 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
3538 btcoexist
->bt_info
.bt_disabled
)
3541 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
3542 if (coex_sta
->c2h_bt_inquiry_page
) {
3543 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
3545 } else if (bt_hs_on
) {
3546 halbtc8723b1ant_action_hs(btcoexist
);
3550 if (BTC_ASSOCIATE_START
== type
) {
3551 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3552 "[BTCoex], CONNECT START notify\n");
3553 halbtc8723b1ant_action_wifi_not_connected_asso_auth_scan(btcoexist
);
3554 } else if (BTC_ASSOCIATE_FINISH
== type
) {
3555 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3556 "[BTCoex], CONNECT FINISH notify\n");
3558 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
3560 if (!wifi_connected
) /* non-connected scan */
3561 halbtc8723b1ant_action_wifi_not_connected(btcoexist
);
3563 halbtc8723b1ant_action_wifi_connected(btcoexist
);
3567 void ex_halbtc8723b1ant_media_status_notify(struct btc_coexist
*btcoexist
,
3570 u8 h2c_parameter
[3] ={0};
3574 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
3575 btcoexist
->bt_info
.bt_disabled
)
3578 if (BTC_MEDIA_CONNECT
== type
)
3579 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3580 "[BTCoex], MEDIA connect notify\n");
3582 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3583 "[BTCoex], MEDIA disconnect notify\n");
3585 /* only 2.4G we need to inform bt the chnl mask */
3586 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_CENTRAL_CHNL
,
3589 if ((BTC_MEDIA_CONNECT
== type
) &&
3590 (wifiCentralChnl
<= 14)) {
3591 h2c_parameter
[0] = 0x0;
3592 h2c_parameter
[1] = wifiCentralChnl
;
3593 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
3594 if (BTC_WIFI_BW_HT40
== wifi_bw
)
3595 h2c_parameter
[2] = 0x30;
3597 h2c_parameter
[2] = 0x20;
3600 coex_dm
->wifi_chnl_info
[0] = h2c_parameter
[0];
3601 coex_dm
->wifi_chnl_info
[1] = h2c_parameter
[1];
3602 coex_dm
->wifi_chnl_info
[2] = h2c_parameter
[2];
3604 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
3605 "[BTCoex], FW write 0x66=0x%x\n",
3606 h2c_parameter
[0] << 16 | h2c_parameter
[1] << 8 |
3609 btcoexist
->btc_fill_h2c(btcoexist
, 0x66, 3, h2c_parameter
);
3612 void ex_halbtc8723b1ant_special_packet_notify(struct btc_coexist
*btcoexist
,
3615 bool bt_hs_on
= false;
3617 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
3618 btcoexist
->bt_info
.bt_disabled
)
3621 coex_sta
->special_pkt_period_cnt
= 0;
3623 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
3624 if (coex_sta
->c2h_bt_inquiry_page
) {
3625 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
3627 } else if (bt_hs_on
) {
3628 halbtc8723b1ant_action_hs(btcoexist
);
3632 if (BTC_PACKET_DHCP
== type
||
3633 BTC_PACKET_EAPOL
== type
) {
3634 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3635 "[BTCoex], special Packet(%d) notify\n", type
);
3636 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist
);
3640 void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist
*btcoexist
,
3641 u8
*tmp_buf
, u8 length
)
3644 u8 i
, rsp_source
= 0;
3645 bool wifi_connected
= false;
3646 bool bt_busy
= false;
3648 coex_sta
->c2h_bt_info_req_sent
= false;
3650 rsp_source
= tmp_buf
[0] & 0xf;
3651 if (rsp_source
>= BT_INFO_SRC_8723B_1ANT_MAX
)
3652 rsp_source
= BT_INFO_SRC_8723B_1ANT_WIFI_FW
;
3653 coex_sta
->bt_info_c2h_cnt
[rsp_source
]++;
3655 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3656 "[BTCoex], Bt info[%d], length=%d, hex data=[",
3657 rsp_source
, length
);
3658 for (i
=0; i
<length
; i
++) {
3659 coex_sta
->bt_info_c2h
[rsp_source
][i
] = tmp_buf
[i
];
3661 bt_info
= tmp_buf
[i
];
3662 if (i
== length
- 1)
3663 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3664 "0x%02x]\n", tmp_buf
[i
]);
3666 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3667 "0x%02x, ", tmp_buf
[i
]);
3670 if (BT_INFO_SRC_8723B_1ANT_WIFI_FW
!= rsp_source
) {
3671 coex_sta
->bt_retry_cnt
= /* [3:0] */
3672 coex_sta
->bt_info_c2h
[rsp_source
][2] & 0xf;
3675 coex_sta
->bt_info_c2h
[rsp_source
][3] * 2 + 10;
3677 coex_sta
->bt_info_ext
=
3678 coex_sta
->bt_info_c2h
[rsp_source
][4];
3680 /* Here we need to resend some wifi info to BT
3681 * because bt is reset and loss of the info.*/
3682 if(coex_sta
->bt_info_ext
& BIT1
)
3684 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3685 "[BTCoex], BT ext info bit1 check, "
3686 "send wifi BW&Chnl to BT!!\n");
3687 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
3690 ex_halbtc8723b1ant_media_status_notify(btcoexist
,
3693 ex_halbtc8723b1ant_media_status_notify(btcoexist
,
3694 BTC_MEDIA_DISCONNECT
);
3697 if (coex_sta
->bt_info_ext
& BIT3
) {
3698 if (!btcoexist
->manual_control
&&
3699 !btcoexist
->stop_coex_dm
) {
3700 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3701 "[BTCoex], BT ext info bit3 check, "
3702 "set BT NOT ignore Wlan active!!\n");
3703 halbtc8723b1ant_ignore_wlan_act(btcoexist
,
3708 /* BT already NOT ignore Wlan active, do nothing here.*/
3710 #if(BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
3711 if (coex_sta
->bt_info_ext
& BIT4
) {
3712 /* BT auto report already enabled, do nothing */
3714 halbtc8723b1ant_bt_auto_report(btcoexist
, FORCE_EXEC
,
3720 /* check BIT2 first ==> check if bt is under inquiry or page scan */
3721 if (bt_info
& BT_INFO_8723B_1ANT_B_INQ_PAGE
)
3722 coex_sta
->c2h_bt_inquiry_page
= true;
3724 coex_sta
->c2h_bt_inquiry_page
= false;
3726 /* set link exist status */
3727 if (!(bt_info
& BT_INFO_8723B_1ANT_B_CONNECTION
)) {
3728 coex_sta
->bt_link_exist
= false;
3729 coex_sta
->pan_exist
= false;
3730 coex_sta
->a2dp_exist
= false;
3731 coex_sta
->hid_exist
= false;
3732 coex_sta
->sco_exist
= false;
3733 } else { /* connection exists */
3734 coex_sta
->bt_link_exist
= true;
3735 if (bt_info
& BT_INFO_8723B_1ANT_B_FTP
)
3736 coex_sta
->pan_exist
= true;
3738 coex_sta
->pan_exist
= false;
3739 if (bt_info
& BT_INFO_8723B_1ANT_B_A2DP
)
3740 coex_sta
->a2dp_exist
= true;
3742 coex_sta
->a2dp_exist
= false;
3743 if (bt_info
& BT_INFO_8723B_1ANT_B_HID
)
3744 coex_sta
->hid_exist
= true;
3746 coex_sta
->hid_exist
= false;
3747 if (bt_info
& BT_INFO_8723B_1ANT_B_SCO_ESCO
)
3748 coex_sta
->sco_exist
= true;
3750 coex_sta
->sco_exist
= false;
3753 halbtc8723b1ant_update_bt_link_info(btcoexist
);
3755 if (!(bt_info
&BT_INFO_8723B_1ANT_B_CONNECTION
)) {
3756 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
;
3757 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3758 "[BTCoex], BtInfoNotify(), "
3759 "BT Non-Connected idle!!!\n");
3760 /* connection exists but no busy */
3761 } else if (bt_info
== BT_INFO_8723B_1ANT_B_CONNECTION
) {
3762 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
;
3763 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3764 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3765 } else if ((bt_info
& BT_INFO_8723B_1ANT_B_SCO_ESCO
) ||
3766 (bt_info
& BT_INFO_8723B_1ANT_B_SCO_BUSY
)) {
3767 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_SCO_BUSY
;
3768 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3769 "[BTCoex], BtInfoNotify(), "
3770 "BT SCO busy!!!\n");
3771 } else if (bt_info
& BT_INFO_8723B_1ANT_B_ACL_BUSY
) {
3772 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
!= coex_dm
->bt_status
)
3773 coex_dm
->auto_tdma_adjust
= false;
3775 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_ACL_BUSY
;
3776 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3777 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3779 coex_dm
->bt_status
=
3780 BT_8723B_1ANT_BT_STATUS_MAX
;
3781 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3782 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n");
3785 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) ||
3786 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
3787 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
))
3791 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_TRAFFIC_BUSY
, &bt_busy
);
3793 halbtc8723b1ant_run_coexist_mechanism(btcoexist
);
3796 void ex_halbtc8723b1ant_halt_notify(struct btc_coexist
*btcoexist
)
3798 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
, "[BTCoex], Halt notify\n");
3800 btcoexist
->stop_coex_dm
= true;
3802 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
, false, true);
3804 halbtc8723b1ant_wifi_off_hw_cfg(btcoexist
);
3805 halbtc8723b1ant_ignore_wlan_act(btcoexist
, FORCE_EXEC
, true);
3807 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
3809 halbtc8723b1ant_ps_tdma(btcoexist
, FORCE_EXEC
, false, 0);
3811 ex_halbtc8723b1ant_media_status_notify(btcoexist
, BTC_MEDIA_DISCONNECT
);
3814 void ex_halbtc8723b1ant_pnp_notify(struct btc_coexist
*btcoexist
, u8 pnp_state
)
3816 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
, "[BTCoex], Pnp notify\n");
3818 if (BTC_WIFI_PNP_SLEEP
== pnp_state
) {
3819 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3820 "[BTCoex], Pnp notify to SLEEP\n");
3821 btcoexist
->stop_coex_dm
= true;
3822 halbtc8723b1ant_ignore_wlan_act(btcoexist
, FORCE_EXEC
, true);
3823 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
3825 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 9);
3826 } else if (BTC_WIFI_PNP_WAKE_UP
== pnp_state
) {
3827 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
3828 "[BTCoex], Pnp notify to WAKE UP\n");
3829 btcoexist
->stop_coex_dm
= false;
3830 halbtc8723b1ant_init_hw_config(btcoexist
, false);
3831 halbtc8723b1ant_init_coex_dm(btcoexist
);
3832 halbtc8723b1ant_query_bt_info(btcoexist
);
3836 void ex_halbtc8723b1ant_periodical(struct btc_coexist
*btcoexist
)
3838 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
3839 struct btc_stack_info
*stack_info
= &btcoexist
->stack_info
;
3840 static u8 dis_ver_info_cnt
= 0;
3841 u32 fw_ver
= 0, bt_patch_ver
= 0;
3843 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
3844 "[BTCoex], =========================="
3845 "Periodical===========================\n");
3847 if (dis_ver_info_cnt
<= 5) {
3848 dis_ver_info_cnt
+= 1;
3849 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3850 "[BTCoex], *************************"
3851 "***************************************\n");
3852 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3853 "[BTCoex], Ant PG Num/ Ant Mech/ "
3854 "Ant Pos = %d/ %d/ %d\n", \
3855 board_info
->pg_ant_num
, board_info
->btdm_ant_num
,
3856 board_info
->btdm_ant_pos
);
3857 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3858 "[BTCoex], BT stack/ hci ext ver = %s / %d\n", \
3859 ((stack_info
->profile_notified
)? "Yes":"No"),
3860 stack_info
->hci_version
);
3861 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_BT_PATCH_VER
,
3863 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
3864 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3865 "[BTCoex], CoexVer/ FwVer/ PatchVer "
3866 "= %d_%x/ 0x%x/ 0x%x(%d)\n", \
3867 glcoex_ver_date_8723b_1ant
,
3868 glcoex_ver_8723b_1ant
, fw_ver
,
3869 bt_patch_ver
, bt_patch_ver
);
3870 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
3871 "[BTCoex], *****************************"
3872 "***********************************\n");
3875 #if(BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
3876 halbtc8723b1ant_query_bt_info(btcoexist
);
3877 halbtc8723b1ant_monitor_bt_ctr(btcoexist
);
3878 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist
);
3880 if (halbtc8723b1ant_is_wifi_status_changed(btcoexist
) ||
3881 coex_dm
->auto_tdma_adjust
) {
3882 if (coex_sta
->special_pkt_period_cnt
> 2)
3883 halbtc8723b1ant_run_coexist_mechanism(btcoexist
);
3886 coex_sta
->special_pkt_period_cnt
++;