4 /* This file is for RTL8821A Co-exist mechanism */
7 /* 2012/11/15 Cosa first check in. */
14 #include "halbt_precomp.h"
16 /* Global variables, these are static variables */
18 static struct coex_dm_8821a_1ant glcoex_dm_8821a_1ant
;
19 static struct coex_dm_8821a_1ant
*coex_dm
= &glcoex_dm_8821a_1ant
;
20 static struct coex_sta_8821a_1ant glcoex_sta_8821a_1ant
;
21 static struct coex_sta_8821a_1ant
*coex_sta
= &glcoex_sta_8821a_1ant
;
23 static const char *const glbt_info_src_8821a_1ant
[] = {
26 "BT Info[bt auto report]",
29 static u32 glcoex_ver_date_8821a_1ant
= 20130816;
30 static u32 glcoex_ver_8821a_1ant
= 0x41;
32 /* local function proto type if needed */
33 /* local function start with halbtc8821a1ant_ */
34 static u8
halbtc8821a1ant_bt_rssi_state(u8 level_num
, u8 rssi_thresh
,
38 u8 bt_rssi_state
= coex_sta
->pre_bt_rssi_state
;
40 bt_rssi
= coex_sta
->bt_rssi
;
43 if ((coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_LOW
) ||
44 (coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_STAY_LOW
)) {
45 if (bt_rssi
>= (rssi_thresh
+BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT
)) {
46 bt_rssi_state
= BTC_RSSI_STATE_HIGH
;
47 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
48 "[BTCoex], BT Rssi state switch to High\n");
50 bt_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
51 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
52 "[BTCoex], BT Rssi state stay at Low\n");
55 if (bt_rssi
< rssi_thresh
) {
56 bt_rssi_state
= BTC_RSSI_STATE_LOW
;
57 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
58 "[BTCoex], BT Rssi state switch to Low\n");
60 bt_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
61 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
62 "[BTCoex], BT Rssi state stay at High\n");
65 } else if (level_num
== 3) {
66 if (rssi_thresh
> rssi_thresh1
) {
67 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
68 "[BTCoex], BT Rssi thresh error!!\n");
69 return coex_sta
->pre_bt_rssi_state
;
72 if ((coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_LOW
) ||
73 (coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_STAY_LOW
)) {
74 if (bt_rssi
>= (rssi_thresh
+BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT
)) {
75 bt_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
76 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
77 "[BTCoex], BT Rssi state switch to Medium\n");
79 bt_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
80 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
81 "[BTCoex], BT Rssi state stay at Low\n");
83 } else if ((coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_MEDIUM
) ||
84 (coex_sta
->pre_bt_rssi_state
== BTC_RSSI_STATE_STAY_MEDIUM
)) {
85 if (bt_rssi
>= (rssi_thresh1
+BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT
)) {
86 bt_rssi_state
= BTC_RSSI_STATE_HIGH
;
87 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
88 "[BTCoex], BT Rssi state switch to High\n");
89 } else if (bt_rssi
< rssi_thresh
) {
90 bt_rssi_state
= BTC_RSSI_STATE_LOW
;
91 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
92 "[BTCoex], BT Rssi state switch to Low\n");
94 bt_rssi_state
= BTC_RSSI_STATE_STAY_MEDIUM
;
95 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
96 "[BTCoex], BT Rssi state stay at Medium\n");
99 if (bt_rssi
< rssi_thresh1
) {
100 bt_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
101 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
102 "[BTCoex], BT Rssi state switch to Medium\n");
104 bt_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
105 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_RSSI_STATE
,
106 "[BTCoex], BT Rssi state stay at High\n");
111 coex_sta
->pre_bt_rssi_state
= bt_rssi_state
;
113 return bt_rssi_state
;
116 static u8
Wifi_rssi_state(struct btc_coexist
*btcoexist
, u8 index
,
117 u8 level_num
, u8 rssi_thresh
,
121 u8 wifi_rssi_state
= coex_sta
->pre_wifi_rssi_state
[index
];
123 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_WIFI_RSSI
, &wifi_rssi
);
125 if (level_num
== 2) {
126 if ((coex_sta
->pre_wifi_rssi_state
[index
] == BTC_RSSI_STATE_LOW
) ||
127 (coex_sta
->pre_wifi_rssi_state
[index
] == BTC_RSSI_STATE_STAY_LOW
)) {
128 if (wifi_rssi
>= (rssi_thresh
+BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT
)) {
129 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
130 BTC_PRINT(BTC_MSG_ALGORITHM
,
131 ALGO_WIFI_RSSI_STATE
,
132 "[BTCoex], wifi RSSI state switch to High\n");
134 wifi_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
135 BTC_PRINT(BTC_MSG_ALGORITHM
,
136 ALGO_WIFI_RSSI_STATE
,
137 "[BTCoex], wifi RSSI state stay at Low\n");
140 if (wifi_rssi
< rssi_thresh
) {
141 wifi_rssi_state
= BTC_RSSI_STATE_LOW
;
142 BTC_PRINT(BTC_MSG_ALGORITHM
,
143 ALGO_WIFI_RSSI_STATE
,
144 "[BTCoex], wifi RSSI state switch to Low\n");
146 wifi_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
147 BTC_PRINT(BTC_MSG_ALGORITHM
,
148 ALGO_WIFI_RSSI_STATE
,
149 "[BTCoex], wifi RSSI state stay at High\n");
152 } else if (level_num
== 3) {
153 if (rssi_thresh
> rssi_thresh1
) {
154 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_WIFI_RSSI_STATE
,
155 "[BTCoex], wifi RSSI thresh error!!\n");
156 return coex_sta
->pre_wifi_rssi_state
[index
];
159 if ((coex_sta
->pre_wifi_rssi_state
[index
] ==
160 BTC_RSSI_STATE_LOW
) ||
161 (coex_sta
->pre_wifi_rssi_state
[index
] ==
162 BTC_RSSI_STATE_STAY_LOW
)) {
163 if (wifi_rssi
>= (rssi_thresh
+
164 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT
)) {
165 wifi_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
166 BTC_PRINT(BTC_MSG_ALGORITHM
,
167 ALGO_WIFI_RSSI_STATE
,
168 "[BTCoex], wifi RSSI state switch to Medium\n");
170 wifi_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
171 BTC_PRINT(BTC_MSG_ALGORITHM
,
172 ALGO_WIFI_RSSI_STATE
,
173 "[BTCoex], wifi RSSI state stay at Low\n");
175 } else if ((coex_sta
->pre_wifi_rssi_state
[index
] ==
176 BTC_RSSI_STATE_MEDIUM
) ||
177 (coex_sta
->pre_wifi_rssi_state
[index
] ==
178 BTC_RSSI_STATE_STAY_MEDIUM
)) {
179 if (wifi_rssi
>= (rssi_thresh1
+
180 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT
)) {
181 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
182 BTC_PRINT(BTC_MSG_ALGORITHM
,
183 ALGO_WIFI_RSSI_STATE
,
184 "[BTCoex], wifi RSSI state switch to High\n");
185 } else if (wifi_rssi
< rssi_thresh
) {
186 wifi_rssi_state
= BTC_RSSI_STATE_LOW
;
187 BTC_PRINT(BTC_MSG_ALGORITHM
,
188 ALGO_WIFI_RSSI_STATE
,
189 "[BTCoex], wifi RSSI state switch to Low\n");
191 wifi_rssi_state
= BTC_RSSI_STATE_STAY_MEDIUM
;
192 BTC_PRINT(BTC_MSG_ALGORITHM
,
193 ALGO_WIFI_RSSI_STATE
,
194 "[BTCoex], wifi RSSI state stay at Medium\n");
197 if (wifi_rssi
< rssi_thresh1
) {
198 wifi_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
199 BTC_PRINT(BTC_MSG_ALGORITHM
,
200 ALGO_WIFI_RSSI_STATE
,
201 "[BTCoex], wifi RSSI state switch to Medium\n");
203 wifi_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
204 BTC_PRINT(BTC_MSG_ALGORITHM
,
205 ALGO_WIFI_RSSI_STATE
,
206 "[BTCoex], wifi RSSI state stay at High\n");
211 coex_sta
->pre_wifi_rssi_state
[index
] = wifi_rssi_state
;
213 return wifi_rssi_state
;
216 static void update_ra_mask(struct btc_coexist
*btcoexist
,
217 bool force_exec
, u32 dis_rate_mask
)
219 coex_dm
->cur_ra_mask
= dis_rate_mask
;
221 if (force_exec
|| (coex_dm
->pre_ra_mask
!= coex_dm
->cur_ra_mask
)) {
222 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_UPDATE_ra_mask
,
223 &coex_dm
->cur_ra_mask
);
225 coex_dm
->pre_ra_mask
= coex_dm
->cur_ra_mask
;
228 static void auto_rate_fallback_retry(struct btc_coexist
*btcoexist
,
229 bool force_exec
, u8 type
)
231 bool wifi_under_b_mode
= false;
233 coex_dm
->cur_arfr_type
= type
;
235 if (force_exec
|| (coex_dm
->pre_arfr_type
!= coex_dm
->cur_arfr_type
)) {
236 switch (coex_dm
->cur_arfr_type
) {
237 case 0: /* normal mode */
238 btcoexist
->btc_write_4byte(btcoexist
, 0x430,
239 coex_dm
->backup_arfr_cnt1
);
240 btcoexist
->btc_write_4byte(btcoexist
, 0x434,
241 coex_dm
->backup_arfr_cnt2
);
244 btcoexist
->btc_get(btcoexist
,
245 BTC_GET_BL_WIFI_UNDER_B_MODE
,
247 if (wifi_under_b_mode
) {
248 btcoexist
->btc_write_4byte(btcoexist
,
250 btcoexist
->btc_write_4byte(btcoexist
,
254 btcoexist
->btc_write_4byte(btcoexist
,
256 btcoexist
->btc_write_4byte(btcoexist
,
266 coex_dm
->pre_arfr_type
= coex_dm
->cur_arfr_type
;
269 static void halbtc8821a1ant_retry_limit(struct btc_coexist
*btcoexist
,
270 bool force_exec
, u8 type
)
272 coex_dm
->cur_retry_limit_type
= type
;
274 if (force_exec
|| (coex_dm
->pre_retry_limit_type
!=
275 coex_dm
->cur_retry_limit_type
)) {
276 switch (coex_dm
->cur_retry_limit_type
) {
277 case 0: /* normal mode */
278 btcoexist
->btc_write_2byte(btcoexist
, 0x42a, coex_dm
->backup_retry_limit
);
280 case 1: /* retry limit = 8 */
281 btcoexist
->btc_write_2byte(btcoexist
, 0x42a, 0x0808);
288 coex_dm
->pre_retry_limit_type
= coex_dm
->cur_retry_limit_type
;
291 static void halbtc8821a1ant_ampdu_max_time(struct btc_coexist
*btcoexist
,
292 bool force_exec
, u8 type
)
294 coex_dm
->cur_ampdu_time_type
= type
;
297 (coex_dm
->pre_ampdu_time_type
!= coex_dm
->cur_ampdu_time_type
)) {
298 switch (coex_dm
->cur_ampdu_time_type
) {
299 case 0: /* normal mode */
300 btcoexist
->btc_write_1byte(btcoexist
, 0x456, coex_dm
->backup_ampdu_max_time
);
302 case 1: /* AMPDU timw = 0x38 * 32us */
303 btcoexist
->btc_write_1byte(btcoexist
, 0x456, 0x38);
310 coex_dm
->pre_ampdu_time_type
= coex_dm
->cur_ampdu_time_type
;
313 static void halbtc8821a1ant_limited_tx(struct btc_coexist
*btcoexist
,
314 bool force_exec
, u8 ra_mask_type
,
315 u8 arfr_type
, u8 retry_limit_type
,
318 switch (ra_mask_type
) {
319 case 0: /* normal mode */
320 update_ra_mask(btcoexist
, force_exec
, 0x0);
322 case 1: /* disable cck 1/2 */
323 update_ra_mask(btcoexist
, force_exec
, 0x00000003);
325 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
326 update_ra_mask(btcoexist
, force_exec
, 0x0001f1f7);
332 auto_rate_fallback_retry(btcoexist
, force_exec
, arfr_type
);
333 halbtc8821a1ant_retry_limit(btcoexist
, force_exec
, retry_limit_type
);
334 halbtc8821a1ant_ampdu_max_time(btcoexist
, force_exec
, ampdu_time_type
);
337 static void halbtc8821a1ant_limited_rx(struct btc_coexist
*btcoexist
,
338 bool force_exec
, bool rej_ap_agg_pkt
,
339 bool bt_ctrl_agg_buf_size
,
342 bool reject_rx_agg
= rej_ap_agg_pkt
;
343 bool bt_ctrl_rx_agg_size
= bt_ctrl_agg_buf_size
;
344 u8 rx_agg_size
= agg_buf_size
;
347 /* Rx Aggregation related setting */
349 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_TO_REJ_AP_AGG_PKT
, &reject_rx_agg
);
350 /* decide BT control aggregation buf size or not */
351 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_CTRL_AGG_SIZE
, &bt_ctrl_rx_agg_size
);
352 /* aggregation buf size, only work when BT control Rx aggregation size. */
353 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_AGG_BUF_SIZE
, &rx_agg_size
);
354 /* real update aggregation setting */
355 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_AGGREGATE_CTRL
, NULL
);
359 static void halbtc8821a1ant_monitor_bt_ctr(struct btc_coexist
*btcoexist
)
361 u32 reg_hp_tx_rx
, reg_lp_tx_rx
, u4_tmp
;
362 u32 reg_hp_tx
= 0, reg_hp_rx
= 0, reg_lp_tx
= 0, reg_lp_rx
= 0;
364 reg_hp_tx_rx
= 0x770;
365 reg_lp_tx_rx
= 0x774;
367 u4_tmp
= btcoexist
->btc_read_4byte(btcoexist
, reg_hp_tx_rx
);
368 reg_hp_tx
= u4_tmp
& MASKLWORD
;
369 reg_hp_rx
= (u4_tmp
& MASKHWORD
)>>16;
371 u4_tmp
= btcoexist
->btc_read_4byte(btcoexist
, reg_lp_tx_rx
);
372 reg_lp_tx
= u4_tmp
& MASKLWORD
;
373 reg_lp_rx
= (u4_tmp
& MASKHWORD
)>>16;
375 coex_sta
->high_priority_tx
= reg_hp_tx
;
376 coex_sta
->high_priority_rx
= reg_hp_rx
;
377 coex_sta
->low_priority_tx
= reg_lp_tx
;
378 coex_sta
->low_priority_rx
= reg_lp_rx
;
381 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0xc);
384 static void halbtc8821a1ant_query_bt_info(struct btc_coexist
*btcoexist
)
386 u8 h2c_parameter
[1] = {0};
388 coex_sta
->c2h_bt_info_req_sent
= true;
390 h2c_parameter
[0] |= BIT(0); /* trigger */
392 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
393 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
396 btcoexist
->btc_fill_h2c(btcoexist
, 0x61, 1, h2c_parameter
);
399 static void halbtc8821a1ant_update_bt_link_info(struct btc_coexist
*btcoexist
)
401 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
402 bool bt_hs_on
= false;
404 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
406 bt_link_info
->bt_link_exist
= coex_sta
->bt_link_exist
;
407 bt_link_info
->sco_exist
= coex_sta
->sco_exist
;
408 bt_link_info
->a2dp_exist
= coex_sta
->a2dp_exist
;
409 bt_link_info
->pan_exist
= coex_sta
->pan_exist
;
410 bt_link_info
->hid_exist
= coex_sta
->hid_exist
;
412 /* work around for HS mode. */
414 bt_link_info
->pan_exist
= true;
415 bt_link_info
->bt_link_exist
= true;
418 /* check if Sco only */
419 if (bt_link_info
->sco_exist
&&
420 !bt_link_info
->a2dp_exist
&&
421 !bt_link_info
->pan_exist
&&
422 !bt_link_info
->hid_exist
)
423 bt_link_info
->sco_only
= true;
425 bt_link_info
->sco_only
= false;
427 /* check if A2dp only */
428 if (!bt_link_info
->sco_exist
&&
429 bt_link_info
->a2dp_exist
&&
430 !bt_link_info
->pan_exist
&&
431 !bt_link_info
->hid_exist
)
432 bt_link_info
->a2dp_only
= true;
434 bt_link_info
->a2dp_only
= false;
436 /* check if Pan only */
437 if (!bt_link_info
->sco_exist
&&
438 !bt_link_info
->a2dp_exist
&&
439 bt_link_info
->pan_exist
&&
440 !bt_link_info
->hid_exist
)
441 bt_link_info
->pan_only
= true;
443 bt_link_info
->pan_only
= false;
445 /* check if Hid only */
446 if (!bt_link_info
->sco_exist
&&
447 !bt_link_info
->a2dp_exist
&&
448 !bt_link_info
->pan_exist
&&
449 bt_link_info
->hid_exist
)
450 bt_link_info
->hid_only
= true;
452 bt_link_info
->hid_only
= false;
455 static u8
halbtc8821a1ant_action_algorithm(struct btc_coexist
*btcoexist
)
457 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
458 bool bt_hs_on
= false;
459 u8 algorithm
= BT_8821A_1ANT_COEX_ALGO_UNDEFINED
;
460 u8 num_of_diff_profile
= 0;
462 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
464 if (!bt_link_info
->bt_link_exist
) {
465 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], No BT link exists!!!\n");
469 if (bt_link_info
->sco_exist
)
470 num_of_diff_profile
++;
471 if (bt_link_info
->hid_exist
)
472 num_of_diff_profile
++;
473 if (bt_link_info
->pan_exist
)
474 num_of_diff_profile
++;
475 if (bt_link_info
->a2dp_exist
)
476 num_of_diff_profile
++;
478 if (num_of_diff_profile
== 1) {
479 if (bt_link_info
->sco_exist
) {
480 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO only\n");
481 algorithm
= BT_8821A_1ANT_COEX_ALGO_SCO
;
483 if (bt_link_info
->hid_exist
) {
484 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = HID only\n");
485 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID
;
486 } else if (bt_link_info
->a2dp_exist
) {
487 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = A2DP only\n");
488 algorithm
= BT_8821A_1ANT_COEX_ALGO_A2DP
;
489 } else if (bt_link_info
->pan_exist
) {
491 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = PAN(HS) only\n");
492 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANHS
;
494 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = PAN(EDR) only\n");
495 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR
;
499 } else if (num_of_diff_profile
== 2) {
500 if (bt_link_info
->sco_exist
) {
501 if (bt_link_info
->hid_exist
) {
502 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + HID\n");
503 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID
;
504 } else if (bt_link_info
->a2dp_exist
) {
505 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
506 algorithm
= BT_8821A_1ANT_COEX_ALGO_SCO
;
507 } else if (bt_link_info
->pan_exist
) {
509 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + PAN(HS)\n");
510 algorithm
= BT_8821A_1ANT_COEX_ALGO_SCO
;
512 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
513 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR_HID
;
517 if (bt_link_info
->hid_exist
&&
518 bt_link_info
->a2dp_exist
) {
519 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = HID + A2DP\n");
520 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID_A2DP
;
521 } else if (bt_link_info
->hid_exist
&&
522 bt_link_info
->pan_exist
) {
524 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = HID + PAN(HS)\n");
525 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID_A2DP
;
527 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = HID + PAN(EDR)\n");
528 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR_HID
;
530 } else if (bt_link_info
->pan_exist
&&
531 bt_link_info
->a2dp_exist
) {
533 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
534 algorithm
= BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS
;
536 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
537 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP
;
541 } else if (num_of_diff_profile
== 3) {
542 if (bt_link_info
->sco_exist
) {
543 if (bt_link_info
->hid_exist
&&
544 bt_link_info
->a2dp_exist
) {
545 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
546 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID
;
547 } else if (bt_link_info
->hid_exist
&&
548 bt_link_info
->pan_exist
) {
550 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
551 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID_A2DP
;
553 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
554 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR_HID
;
556 } else if (bt_link_info
->pan_exist
&&
557 bt_link_info
->a2dp_exist
) {
559 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
560 algorithm
= BT_8821A_1ANT_COEX_ALGO_SCO
;
562 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
563 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR_HID
;
567 if (bt_link_info
->hid_exist
&&
568 bt_link_info
->pan_exist
&&
569 bt_link_info
->a2dp_exist
) {
571 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
572 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID_A2DP
;
574 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
575 algorithm
= BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR
;
579 } else if (num_of_diff_profile
>= 3) {
580 if (bt_link_info
->sco_exist
) {
581 if (bt_link_info
->hid_exist
&&
582 bt_link_info
->pan_exist
&&
583 bt_link_info
->a2dp_exist
) {
585 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
587 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR) ==>PAN(EDR)+HID\n");
588 algorithm
= BT_8821A_1ANT_COEX_ALGO_PANEDR_HID
;
597 static void halbtc8821a1ant_set_bt_auto_report(struct btc_coexist
*btcoexist
,
598 bool enable_auto_report
)
600 u8 h2c_parameter
[1] = {0};
602 h2c_parameter
[0] = 0;
604 if (enable_auto_report
)
605 h2c_parameter
[0] |= BIT(0);
607 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
608 "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
609 (enable_auto_report
? "Enabled!!" : "Disabled!!"),
612 btcoexist
->btc_fill_h2c(btcoexist
, 0x68, 1, h2c_parameter
);
615 static void halbtc8821a1ant_bt_auto_report(struct btc_coexist
*btcoexist
,
617 bool enable_auto_report
)
619 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
, "[BTCoex], %s BT Auto report = %s\n",
620 (force_exec
? "force to" : ""), ((enable_auto_report
) ? "Enabled" : "Disabled"));
621 coex_dm
->cur_bt_auto_report
= enable_auto_report
;
624 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], pre_bt_auto_report =%d, cur_bt_auto_report =%d\n",
625 coex_dm
->pre_bt_auto_report
, coex_dm
->cur_bt_auto_report
);
627 if (coex_dm
->pre_bt_auto_report
== coex_dm
->cur_bt_auto_report
)
630 halbtc8821a1ant_set_bt_auto_report(btcoexist
, coex_dm
->cur_bt_auto_report
);
632 coex_dm
->pre_bt_auto_report
= coex_dm
->cur_bt_auto_report
;
635 static void set_sw_penalty_tx_rate_adaptive(struct btc_coexist
*btcoexist
,
638 u8 h2c_parameter
[6] = {0};
640 h2c_parameter
[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
642 if (low_penalty_ra
) {
643 h2c_parameter
[1] |= BIT(0);
644 h2c_parameter
[2] = 0x00; /* normal rate except MCS7/6/5,
646 h2c_parameter
[3] = 0xf7; /* MCS7 or OFDM54 */
647 h2c_parameter
[4] = 0xf8; /* MCS6 or OFDM48 */
648 h2c_parameter
[5] = 0xf9; /* MCS5 or OFDM36 */
651 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
652 "[BTCoex], set WiFi Low-Penalty Retry: %s",
653 (low_penalty_ra
? "ON!!" : "OFF!!"));
655 btcoexist
->btc_fill_h2c(btcoexist
, 0x69, 6, h2c_parameter
);
658 static void halbtc8821a1ant_low_penalty_ra(struct btc_coexist
*btcoexist
,
659 bool force_exec
, bool low_penalty_ra
)
661 coex_dm
->cur_low_penalty_ra
= low_penalty_ra
;
664 if (coex_dm
->pre_low_penalty_ra
== coex_dm
->cur_low_penalty_ra
)
667 set_sw_penalty_tx_rate_adaptive(btcoexist
, coex_dm
->cur_low_penalty_ra
);
669 coex_dm
->pre_low_penalty_ra
= coex_dm
->cur_low_penalty_ra
;
672 static void halbtc8821a1ant_set_coex_table(struct btc_coexist
*btcoexist
,
673 u32 val0x6c0
, u32 val0x6c4
,
674 u32 val0x6c8
, u8 val0x6cc
)
676 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
677 "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0
);
678 btcoexist
->btc_write_4byte(btcoexist
, 0x6c0, val0x6c0
);
680 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
681 "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4
);
682 btcoexist
->btc_write_4byte(btcoexist
, 0x6c4, val0x6c4
);
684 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
685 "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8
);
686 btcoexist
->btc_write_4byte(btcoexist
, 0x6c8, val0x6c8
);
688 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW_EXEC
,
689 "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc
);
690 btcoexist
->btc_write_1byte(btcoexist
, 0x6cc, val0x6cc
);
693 static void halbtc8821a1ant_coex_table(struct btc_coexist
*btcoexist
,
694 bool force_exec
, u32 val0x6c0
,
695 u32 val0x6c4
, u32 val0x6c8
, u8 val0x6cc
)
697 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_SW
,
698 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
699 (force_exec
? "force to" : ""), val0x6c0
, val0x6c4
,
701 coex_dm
->cur_val_0x6c0
= val0x6c0
;
702 coex_dm
->cur_val_0x6c4
= val0x6c4
;
703 coex_dm
->cur_val_0x6c8
= val0x6c8
;
704 coex_dm
->cur_val_0x6cc
= val0x6cc
;
707 if ((coex_dm
->pre_val_0x6c0
== coex_dm
->cur_val_0x6c0
) &&
708 (coex_dm
->pre_val_0x6c4
== coex_dm
->cur_val_0x6c4
) &&
709 (coex_dm
->pre_val_0x6c8
== coex_dm
->cur_val_0x6c8
) &&
710 (coex_dm
->pre_val_0x6cc
== coex_dm
->cur_val_0x6cc
))
713 halbtc8821a1ant_set_coex_table(btcoexist
, val0x6c0
, val0x6c4
,
716 coex_dm
->pre_val_0x6c0
= coex_dm
->cur_val_0x6c0
;
717 coex_dm
->pre_val_0x6c4
= coex_dm
->cur_val_0x6c4
;
718 coex_dm
->pre_val_0x6c8
= coex_dm
->cur_val_0x6c8
;
719 coex_dm
->pre_val_0x6cc
= coex_dm
->cur_val_0x6cc
;
722 static void halbtc8821a1ant_coex_table_with_type(struct btc_coexist
*btcoexist
,
723 bool force_exec
, u8 type
)
727 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
728 0x55555555, 0x55555555,
732 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
733 0x55555555, 0x5a5a5a5a,
737 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
738 0x5a5a5a5a, 0x5a5a5a5a,
742 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
743 0x55555555, 0xaaaaaaaa,
747 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
748 0xffffffff, 0xffffffff,
752 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
753 0x5fff5fff, 0x5fff5fff,
757 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
758 0x55ff55ff, 0x5a5a5a5a,
762 halbtc8821a1ant_coex_table(btcoexist
, force_exec
,
763 0x5afa5afa, 0x5afa5afa,
771 static void halbtc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist
*btcoexist
,
774 u8 h2c_parameter
[1] = {0};
777 h2c_parameter
[0] |= BIT(0); /* function enable */
779 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
780 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
783 btcoexist
->btc_fill_h2c(btcoexist
, 0x63, 1, h2c_parameter
);
786 static void halbtc8821a1ant_ignore_wlan_act(struct btc_coexist
*btcoexist
,
787 bool force_exec
, bool enable
)
789 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
,
790 "[BTCoex], %s turn Ignore WlanAct %s\n",
791 (force_exec
? "force to" : ""), (enable
? "ON" : "OFF"));
792 coex_dm
->cur_ignore_wlan_act
= enable
;
795 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
,
796 "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
797 coex_dm
->pre_ignore_wlan_act
,
798 coex_dm
->cur_ignore_wlan_act
);
800 if (coex_dm
->pre_ignore_wlan_act
==
801 coex_dm
->cur_ignore_wlan_act
)
804 halbtc8821a1ant_set_fw_ignore_wlan_act(btcoexist
, enable
);
806 coex_dm
->pre_ignore_wlan_act
= coex_dm
->cur_ignore_wlan_act
;
810 halbtc8821a1ant_set_fw_pstdma(
811 struct btc_coexist
*btcoexist
,
819 u8 h2c_parameter
[5] = {0};
821 h2c_parameter
[0] = byte1
;
822 h2c_parameter
[1] = byte2
;
823 h2c_parameter
[2] = byte3
;
824 h2c_parameter
[3] = byte4
;
825 h2c_parameter
[4] = byte5
;
827 coex_dm
->ps_tdma_para
[0] = byte1
;
828 coex_dm
->ps_tdma_para
[1] = byte2
;
829 coex_dm
->ps_tdma_para
[2] = byte3
;
830 coex_dm
->ps_tdma_para
[3] = byte4
;
831 coex_dm
->ps_tdma_para
[4] = byte5
;
833 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
, "[BTCoex], PS-TDMA H2C cmd = 0x%x%08x\n",
835 h2c_parameter
[1]<<24|h2c_parameter
[2]<<16|h2c_parameter
[3]<<8|h2c_parameter
[4]);
837 btcoexist
->btc_fill_h2c(btcoexist
, 0x60, 5, h2c_parameter
);
841 halbtc8821a1ant_set_lps_rpwm(
842 struct btc_coexist
*btcoexist
,
850 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_LPS_VAL
, &lps
);
851 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_RPWM_VAL
, &rpwm
);
855 halbtc8821a1ant_lps_rpwm(
856 struct btc_coexist
*btcoexist
,
862 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
, "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
863 (force_exec
? "force to" : ""), lps_val
, rpwm_val
);
864 coex_dm
->cur_lps
= lps_val
;
865 coex_dm
->cur_rpwm
= rpwm_val
;
868 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n",
869 coex_dm
->cur_lps
, coex_dm
->cur_rpwm
);
871 if ((coex_dm
->pre_lps
== coex_dm
->cur_lps
) &&
872 (coex_dm
->pre_rpwm
== coex_dm
->cur_rpwm
)) {
873 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n",
874 coex_dm
->pre_rpwm
, coex_dm
->cur_rpwm
);
879 halbtc8821a1ant_set_lps_rpwm(btcoexist
, lps_val
, rpwm_val
);
881 coex_dm
->pre_lps
= coex_dm
->cur_lps
;
882 coex_dm
->pre_rpwm
= coex_dm
->cur_rpwm
;
886 halbtc8821a1ant_sw_mechanism(
887 struct btc_coexist
*btcoexist
,
891 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
, "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra
);
893 halbtc8821a1ant_low_penalty_ra(btcoexist
, NORMAL_EXEC
, low_penalty_ra
);
897 halbtc8821a1ant_set_ant_path(
898 struct btc_coexist
*btcoexist
,
904 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
906 u8 h2c_parameter
[2] = {0};
909 /* 0x4c[23] = 0, 0x4c[24] = 1 Antenna control by WL/BT */
910 u4_tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
913 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u4_tmp
);
915 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x975, 0x3, 0x3);
916 btcoexist
->btc_write_1byte(btcoexist
, 0xcb4, 0x77);
918 if (board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
) {
919 /* tell firmware "antenna inverse" ==> WRONG firmware antenna control code.==>need fw to fix */
920 h2c_parameter
[0] = 1;
921 h2c_parameter
[1] = 1;
922 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2, h2c_parameter
);
924 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x64, 0x1, 0x1); /* Main Ant to BT for IPS case 0x4c[23] = 1 */
926 /* tell firmware "no antenna inverse" ==> WRONG firmware antenna control code.==>need fw to fix */
927 h2c_parameter
[0] = 0;
928 h2c_parameter
[1] = 1;
929 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2, h2c_parameter
);
931 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x64, 0x1, 0x0); /* Aux Ant to BT for IPS case 0x4c[23] = 1 */
933 } else if (wifi_off
) {
934 /* 0x4c[24:23] = 00, Set Antenna control by BT_RFE_CTRL BT Vendor 0xac = 0xf002 */
935 u4_tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
938 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u4_tmp
);
941 /* ext switch setting */
942 switch (ant_pos_type
) {
943 case BTC_ANT_PATH_WIFI
:
944 if (board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
945 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0xcb7, 0x30, 0x1);
947 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0xcb7, 0x30, 0x2);
949 case BTC_ANT_PATH_BT
:
950 if (board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
951 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0xcb7, 0x30, 0x2);
953 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0xcb7, 0x30, 0x1);
955 case BTC_ANT_PATH_PTA
:
957 if (board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
958 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0xcb7, 0x30, 0x1);
960 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0xcb7, 0x30, 0x2);
966 halbtc8821a1ant_ps_tdma(
967 struct btc_coexist
*btcoexist
,
973 u8 rssi_adjust_val
= 0;
975 coex_dm
->cur_ps_tdma_on
= turn_on
;
976 coex_dm
->cur_ps_tdma
= type
;
979 if (coex_dm
->cur_ps_tdma_on
) {
980 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], ********** TDMA(on, %d) **********\n",
981 coex_dm
->cur_ps_tdma
);
983 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], ********** TDMA(off, %d) **********\n",
984 coex_dm
->cur_ps_tdma
);
987 if ((coex_dm
->pre_ps_tdma_on
== coex_dm
->cur_ps_tdma_on
) &&
988 (coex_dm
->pre_ps_tdma
== coex_dm
->cur_ps_tdma
))
994 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x1a, 0x1a, 0x0, 0x50);
997 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x3a, 0x03, 0x10, 0x50);
998 rssi_adjust_val
= 11;
1001 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x2b, 0x03, 0x10, 0x50);
1002 rssi_adjust_val
= 14;
1005 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x1d, 0x1d, 0x0, 0x10);
1008 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x93, 0x15, 0x3, 0x14, 0x0);
1009 rssi_adjust_val
= 17;
1012 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x61, 0x15, 0x3, 0x11, 0x10);
1015 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x13, 0xa, 0x3, 0x0, 0x0);
1018 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x13, 0xc, 0x5, 0x0, 0x0);
1021 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x93, 0x25, 0x3, 0x10, 0x0);
1024 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x21, 0x3, 0x10, 0x50);
1025 rssi_adjust_val
= 18;
1028 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x13, 0xa, 0xa, 0x0, 0x40);
1031 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x14, 0x03, 0x10, 0x10);
1032 rssi_adjust_val
= 20;
1035 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x0a, 0x0a, 0x0, 0x50);
1038 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x18, 0x18, 0x0, 0x10);
1041 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x21, 0x3, 0x10, 0x10);
1044 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x13, 0xa, 0x3, 0x8, 0x0);
1047 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x93, 0x15, 0x3, 0x10, 0x0);
1048 rssi_adjust_val
= 18;
1051 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x93, 0x25, 0x3, 0x10, 0x0);
1052 rssi_adjust_val
= 14;
1055 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x61, 0x35, 0x03, 0x11, 0x10);
1058 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x61, 0x15, 0x03, 0x11, 0x10);
1061 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x61, 0x25, 0x03, 0x11, 0x10);
1064 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xe3, 0x25, 0x3, 0x31, 0x18);
1065 rssi_adjust_val
= 22;
1068 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xe3, 0x15, 0x3, 0x31, 0x18);
1069 rssi_adjust_val
= 22;
1072 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xe3, 0xa, 0x3, 0x31, 0x18);
1073 rssi_adjust_val
= 22;
1076 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xe3, 0xa, 0x3, 0x31, 0x18);
1077 rssi_adjust_val
= 22;
1080 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xe3, 0x25, 0x3, 0x31, 0x98);
1081 rssi_adjust_val
= 22;
1084 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x69, 0x25, 0x3, 0x31, 0x0);
1087 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xab, 0x1a, 0x1a, 0x1, 0x10);
1090 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x51, 0x14, 0x3, 0x10, 0x50);
1093 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xd3, 0x1a, 0x1a, 0, 0x58);
1096 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x61, 0xa, 0x3, 0x10, 0x0);
1099 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xa3, 0x25, 0x3, 0x30, 0x90);
1102 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x53, 0x1a, 0x1a, 0x0, 0x10);
1105 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x63, 0x1a, 0x1a, 0x0, 0x10);
1108 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0xd3, 0x12, 0x3, 0x14, 0x50);
1112 /* disable PS tdma */
1114 case 8: /* PTA Control */
1115 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x8, 0x0, 0x0, 0x0, 0x0);
1116 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_PTA
, false, false);
1119 default: /* Software control, Antenna at BT side */
1120 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x0, 0x0, 0x0, 0x0, 0x0);
1121 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_BT
, false, false);
1123 case 9: /* Software control, Antenna at WiFi side */
1124 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x0, 0x0, 0x0, 0x0, 0x0);
1125 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_WIFI
, false, false);
1127 case 10: /* under 5G */
1128 halbtc8821a1ant_set_fw_pstdma(btcoexist
, 0x0, 0x0, 0x0, 0x8, 0x0);
1129 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_BT
, false, false);
1133 rssi_adjust_val
= 0;
1134 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE
, &rssi_adjust_val
);
1136 /* update pre state */
1137 coex_dm
->pre_ps_tdma_on
= coex_dm
->cur_ps_tdma_on
;
1138 coex_dm
->pre_ps_tdma
= coex_dm
->cur_ps_tdma
;
1142 halbtc8821a1ant_is_common_action(
1143 struct btc_coexist
*btcoexist
1146 bool bCommon
= false, wifi_connected
= false, wifi_busy
= false;
1148 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
, &wifi_connected
);
1149 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
1151 if (!wifi_connected
&&
1152 BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE
== coex_dm
->bt_status
) {
1153 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
1154 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1157 } else if (wifi_connected
&&
1158 (BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE
== coex_dm
->bt_status
)) {
1159 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1160 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1163 } else if (!wifi_connected
&&
1164 (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE
== coex_dm
->bt_status
)) {
1165 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
1166 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1169 } else if (wifi_connected
&&
1170 (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE
== coex_dm
->bt_status
)) {
1171 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi connected + BT connected-idle!!\n");
1172 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1175 } else if (!wifi_connected
&&
1176 (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE
!= coex_dm
->bt_status
)) {
1177 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
1178 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1183 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1185 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1195 halbtc8821a1ant_tdma_duration_adjust_for_acl(
1196 struct btc_coexist
*btcoexist
,
1200 static long up
, dn
, m
, n
, wait_count
;
1201 long result
; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
1202 u8 retry_count
= 0, bt_info_ext
;
1204 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW
, "[BTCoex], TdmaDurationAdjustForAcl()\n");
1206 if ((BT_8821A_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN
== wifi_status
) ||
1207 (BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN
== wifi_status
) ||
1208 (BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT
== wifi_status
)) {
1209 if (coex_dm
->cur_ps_tdma
!= 1 &&
1210 coex_dm
->cur_ps_tdma
!= 2 &&
1211 coex_dm
->cur_ps_tdma
!= 3 &&
1212 coex_dm
->cur_ps_tdma
!= 9) {
1213 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 9);
1214 coex_dm
->ps_tdma_du_adj_type
= 9;
1226 if (!coex_dm
->auto_tdma_adjust
) {
1227 coex_dm
->auto_tdma_adjust
= true;
1228 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], first run TdmaDurationAdjust()!!\n");
1230 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 2);
1231 coex_dm
->ps_tdma_du_adj_type
= 2;
1240 /* accquire the BT TRx retry count from BT_Info byte2 */
1241 retry_count
= coex_sta
->bt_retry_cnt
;
1242 bt_info_ext
= coex_sta
->bt_info_ext
;
1243 /* BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], retry_count = %d\n", retry_count)); */
1244 /* BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], up =%d, dn =%d, m =%d, n =%d, wait_count =%d\n", */
1245 /* up, dn, m, n, wait_count)); */
1249 if (retry_count
== 0) {
1250 /* no retry in the last 2-second duration */
1263 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], Increase wifi duration!!\n");
1265 } else if (retry_count
<= 3) {
1273 if (wait_count
<= 2)
1285 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1288 if (wait_count
== 1)
1300 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1304 if ((BT_INFO_8821A_1ANT_A2DP_BASIC_RATE(bt_info_ext
)) &&
1305 ((coex_dm
->cur_ps_tdma
== 1) || (coex_dm
->cur_ps_tdma
== 2))) {
1306 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 9);
1307 coex_dm
->ps_tdma_du_adj_type
= 9;
1308 } else if (coex_dm
->cur_ps_tdma
== 1) {
1309 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 2);
1310 coex_dm
->ps_tdma_du_adj_type
= 2;
1311 } else if (coex_dm
->cur_ps_tdma
== 2) {
1312 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 9);
1313 coex_dm
->ps_tdma_du_adj_type
= 9;
1314 } else if (coex_dm
->cur_ps_tdma
== 9) {
1315 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 11);
1316 coex_dm
->ps_tdma_du_adj_type
= 11;
1318 } else if (result
== 1) {
1319 if ((BT_INFO_8821A_1ANT_A2DP_BASIC_RATE(bt_info_ext
)) &&
1320 ((coex_dm
->cur_ps_tdma
== 1) || (coex_dm
->cur_ps_tdma
== 2))) {
1321 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 9);
1322 coex_dm
->ps_tdma_du_adj_type
= 9;
1323 } else if (coex_dm
->cur_ps_tdma
== 11) {
1324 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 9);
1325 coex_dm
->ps_tdma_du_adj_type
= 9;
1326 } else if (coex_dm
->cur_ps_tdma
== 9) {
1327 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 2);
1328 coex_dm
->ps_tdma_du_adj_type
= 2;
1329 } else if (coex_dm
->cur_ps_tdma
== 2) {
1330 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 1);
1331 coex_dm
->ps_tdma_du_adj_type
= 1;
1335 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_DETAIL
, "[BTCoex], ********** TDMA(on, %d) **********\n",
1336 coex_dm
->cur_ps_tdma
);
1339 if (coex_dm
->cur_ps_tdma
!= 1 &&
1340 coex_dm
->cur_ps_tdma
!= 2 &&
1341 coex_dm
->cur_ps_tdma
!= 9 &&
1342 coex_dm
->cur_ps_tdma
!= 11) {
1343 /* recover to previous adjust type */
1344 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, coex_dm
->ps_tdma_du_adj_type
);
1350 halbtc8821a1ant_ps_tdma_check_for_power_save_state(
1351 struct btc_coexist
*btcoexist
,
1357 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_LPS_MODE
, &lps_mode
);
1360 /* already under LPS state */
1361 if (!new_ps_state
) {
1362 /* will leave LPS state, turn off psTdma first */
1363 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 0);
1368 /* will enter LPS state, turn off psTdma first */
1369 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 0);
1371 /* keep state under NO PS state, do nothing. */
1377 halbtc8821a1ant_power_save_state(
1378 struct btc_coexist
*btcoexist
,
1384 bool low_pwr_disable
= false;
1387 case BTC_PS_WIFI_NATIVE
:
1388 /* recover to original 32k low power setting */
1389 low_pwr_disable
= false;
1390 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_DISABLE_LOW_POWER
, &low_pwr_disable
);
1391 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_NORMAL_LPS
, NULL
);
1394 halbtc8821a1ant_ps_tdma_check_for_power_save_state(btcoexist
, true);
1395 halbtc8821a1ant_lps_rpwm(btcoexist
, NORMAL_EXEC
, lps_val
, rpwm_val
);
1396 /* when coex force to enter LPS, do not enter 32k low power. */
1397 low_pwr_disable
= true;
1398 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_DISABLE_LOW_POWER
, &low_pwr_disable
);
1399 /* power save must executed before psTdma. */
1400 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_ENTER_LPS
, NULL
);
1402 case BTC_PS_LPS_OFF
:
1403 halbtc8821a1ant_ps_tdma_check_for_power_save_state(btcoexist
, false);
1404 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_LEAVE_LPS
, NULL
);
1412 halbtc8821a1ant_coex_under_5g(
1413 struct btc_coexist
*btcoexist
1416 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1418 halbtc8821a1ant_ignore_wlan_act(btcoexist
, NORMAL_EXEC
, true);
1420 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 10);
1422 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
1424 halbtc8821a1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
1426 halbtc8821a1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false, false, 5);
1430 halbtc8821a1ant_action_wifi_only(
1431 struct btc_coexist
*btcoexist
1434 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
1435 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 9);
1439 halbtc8821a1ant_monitor_bt_enable_disable(
1440 struct btc_coexist
*btcoexist
1443 static bool pre_bt_disabled
;
1444 static u32 bt_disable_cnt
;
1445 bool bt_active
= true, bt_disabled
= false;
1447 /* This function check if bt is disabled */
1449 if (coex_sta
->high_priority_tx
== 0 &&
1450 coex_sta
->high_priority_rx
== 0 &&
1451 coex_sta
->low_priority_tx
== 0 &&
1452 coex_sta
->low_priority_rx
== 0) {
1455 if (coex_sta
->high_priority_tx
== 0xffff &&
1456 coex_sta
->high_priority_rx
== 0xffff &&
1457 coex_sta
->low_priority_tx
== 0xffff &&
1458 coex_sta
->low_priority_rx
== 0xffff) {
1463 bt_disabled
= false;
1464 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_DISABLE
,
1466 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1467 "[BTCoex], BT is enabled !!\n");
1470 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1471 "[BTCoex], bt all counters = 0, %d times!!\n",
1473 if (bt_disable_cnt
>= 2) {
1475 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_DISABLE
,
1477 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1478 "[BTCoex], BT is disabled !!\n");
1479 halbtc8821a1ant_action_wifi_only(btcoexist
);
1482 if (pre_bt_disabled
!= bt_disabled
) {
1483 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_BT_MONITOR
,
1484 "[BTCoex], BT is from %s to %s!!\n",
1485 (pre_bt_disabled
? "disabled" : "enabled"),
1486 (bt_disabled
? "disabled" : "enabled"));
1487 pre_bt_disabled
= bt_disabled
;
1489 btcoexist
->btc_set(btcoexist
,
1490 BTC_SET_ACT_LEAVE_LPS
, NULL
);
1491 btcoexist
->btc_set(btcoexist
,
1492 BTC_SET_ACT_NORMAL_LPS
, NULL
);
1497 /* Software Coex Mechanism start */
1498 static void halbtc8821a1ant_action_sco(struct btc_coexist
*btcoexist
)
1500 halbtc8821a1ant_sw_mechanism(btcoexist
, true);
1503 static void halbtc8821a1ant_action_hid(struct btc_coexist
*btcoexist
)
1505 halbtc8821a1ant_sw_mechanism(btcoexist
, true);
1508 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
1509 static void halbtc8821a1ant_action_a2dp(struct btc_coexist
*btcoexist
)
1511 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1514 static void halbtc8821a1ant_action_a2dp_pan_hs(struct btc_coexist
*btcoexist
)
1516 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1519 static void halbtc8821a1ant_action_pan_edr(struct btc_coexist
*btcoexist
)
1521 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1525 static void halbtc8821a1ant_action_pan_hs(struct btc_coexist
*btcoexist
)
1527 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1531 static void halbtc8821a1ant_action_pan_edr_a2dp(struct btc_coexist
*btcoexist
)
1533 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1536 static void halbtc8821a1ant_action_pan_edr_hid(struct btc_coexist
*btcoexist
)
1538 halbtc8821a1ant_sw_mechanism(btcoexist
, true);
1541 /* HID+A2DP+PAN(EDR) */
1542 static void halbtc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist
*btcoexist
)
1544 halbtc8821a1ant_sw_mechanism(btcoexist
, true);
1547 static void halbtc8821a1ant_action_hid_a2dp(struct btc_coexist
*btcoexist
)
1549 halbtc8821a1ant_sw_mechanism(btcoexist
, true);
1552 /* Non-Software Coex Mechanism start */
1553 static void halbtc8821a1ant_action_hs(struct btc_coexist
*btcoexist
)
1555 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
1556 halbtc8821a1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 2);
1559 static void halbtc8821a1ant_action_bt_inquiry(struct btc_coexist
*btcoexist
)
1561 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1562 bool wifi_connected
= false;
1564 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
, &wifi_connected
);
1566 if (!wifi_connected
) {
1567 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1568 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
1569 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1570 } else if ((bt_link_info
->sco_exist
) ||
1571 (bt_link_info
->hid_only
)) {
1572 /* SCO/HID-only busy */
1573 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1574 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 32);
1575 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1577 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_LPS_ON
, 0x50, 0x4);
1578 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 30);
1579 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1584 halbtc8821a1ant_action_bt_sco_hid_only_busy(
1585 struct btc_coexist
*btcoexist
,
1589 /* tdma and coex table */
1590 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
1592 if (BT_8821A_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN
== wifi_status
)
1593 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1595 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1598 static void action_wifi_connected_bt_acl_busy(struct btc_coexist
*btcoexist
, u8 wifi_status
)
1602 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1603 bt_rssi_state
= halbtc8821a1ant_bt_rssi_state(2, 28, 0);
1605 if (bt_link_info
->hid_only
) {
1607 halbtc8821a1ant_action_bt_sco_hid_only_busy(btcoexist
, wifi_status
);
1608 coex_dm
->auto_tdma_adjust
= false;
1610 } else if (bt_link_info
->a2dp_only
) { /* A2DP */
1611 if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
1612 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
1613 halbtc8821a1ant_tdma_duration_adjust_for_acl(btcoexist
, wifi_status
);
1614 } else { /* for low BT RSSI */
1615 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 11);
1616 coex_dm
->auto_tdma_adjust
= false;
1619 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1620 } else if (bt_link_info
->hid_exist
&& bt_link_info
->a2dp_exist
) {
1622 if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
1623 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
1624 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 14);
1625 coex_dm
->auto_tdma_adjust
= false;
1626 } else /* for low BT RSSI */ {
1627 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 11);
1628 coex_dm
->auto_tdma_adjust
= false;
1631 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1632 } else if ((bt_link_info
->pan_only
) || (bt_link_info
->hid_exist
&& bt_link_info
->pan_exist
)) {
1633 /* PAN(OPP, FTP), HID+PAN(OPP, FTP) */
1634 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 3);
1635 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1636 coex_dm
->auto_tdma_adjust
= false;
1637 } else if (((bt_link_info
->a2dp_exist
) && (bt_link_info
->pan_exist
)) ||
1638 (bt_link_info
->hid_exist
&& bt_link_info
->a2dp_exist
&&
1639 bt_link_info
->pan_exist
)) {
1640 /* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */
1641 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 13);
1642 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1643 coex_dm
->auto_tdma_adjust
= false;
1645 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 11);
1646 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1647 coex_dm
->auto_tdma_adjust
= false;
1652 halbtc8821a1ant_action_wifi_not_connected(
1653 struct btc_coexist
*btcoexist
1656 /* power save state */
1657 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1659 /* tdma and coex table */
1660 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
1661 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
1664 static void wifi_not_connected_asso_auth_scan(struct btc_coexist
*btcoexist
)
1666 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1668 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 22);
1669 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1673 halbtc8821a1ant_action_wifi_connected_scan(
1674 struct btc_coexist
*btcoexist
1677 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1679 /* power save state */
1680 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1682 /* tdma and coex table */
1683 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
1684 if (bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) {
1685 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 22);
1686 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1688 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
1689 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1691 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
1692 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
)) {
1693 halbtc8821a1ant_action_bt_sco_hid_only_busy(btcoexist
,
1694 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN
);
1696 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
1697 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1701 static void action_wifi_connected_special_packet(struct btc_coexist
*btcoexist
)
1703 bool hs_connecting
= false;
1704 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1706 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_CONNECTING
, &hs_connecting
);
1708 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1710 /* tdma and coex table */
1711 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
1712 if (bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) {
1713 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 22);
1714 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1716 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
1717 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1720 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
1721 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1725 static void halbtc8821a1ant_action_wifi_connected(struct btc_coexist
*btcoexist
)
1727 bool wifi_busy
= false;
1728 bool scan
= false, link
= false, roam
= false;
1729 bool under_4way
= false;
1731 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], CoexForWifiConnect() ===>\n");
1733 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_4_WAY_PROGRESS
, &under_4way
);
1735 action_wifi_connected_special_packet(btcoexist
);
1736 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
1740 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
1741 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
1742 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
1743 if (scan
|| link
|| roam
) {
1744 halbtc8821a1ant_action_wifi_connected_scan(btcoexist
);
1745 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
1749 /* power save state */
1750 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
&& !btcoexist
->bt_link_info
.hid_only
)
1751 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_LPS_ON
, 0x50, 0x4);
1753 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1755 /* tdma and coex table */
1756 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
1758 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
1759 action_wifi_connected_bt_acl_busy(btcoexist
,
1760 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
1761 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
1762 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
)) {
1763 halbtc8821a1ant_action_bt_sco_hid_only_busy(btcoexist
,
1764 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
1766 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
1767 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
1770 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
1771 action_wifi_connected_bt_acl_busy(btcoexist
,
1772 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
1773 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY
==
1774 coex_dm
->bt_status
) ||
1775 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY
==
1776 coex_dm
->bt_status
)) {
1777 halbtc8821a1ant_action_bt_sco_hid_only_busy(btcoexist
,
1778 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
1780 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1782 halbtc8821a1ant_coex_table_with_type(btcoexist
,
1788 static void run_sw_coexist_mechanism(struct btc_coexist
*btcoexist
)
1792 algorithm
= halbtc8821a1ant_action_algorithm(btcoexist
);
1793 coex_dm
->cur_algorithm
= algorithm
;
1795 if (!halbtc8821a1ant_is_common_action(btcoexist
)) {
1796 switch (coex_dm
->cur_algorithm
) {
1797 case BT_8821A_1ANT_COEX_ALGO_SCO
:
1798 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1799 "[BTCoex], Action algorithm = SCO.\n");
1800 halbtc8821a1ant_action_sco(btcoexist
);
1802 case BT_8821A_1ANT_COEX_ALGO_HID
:
1803 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1804 "[BTCoex], Action algorithm = HID.\n");
1805 halbtc8821a1ant_action_hid(btcoexist
);
1807 case BT_8821A_1ANT_COEX_ALGO_A2DP
:
1808 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1809 "[BTCoex], Action algorithm = A2DP.\n");
1810 halbtc8821a1ant_action_a2dp(btcoexist
);
1812 case BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS
:
1813 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1814 "[BTCoex], Action algorithm = A2DP+PAN(HS).\n");
1815 halbtc8821a1ant_action_a2dp_pan_hs(btcoexist
);
1817 case BT_8821A_1ANT_COEX_ALGO_PANEDR
:
1818 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1819 "[BTCoex], Action algorithm = PAN(EDR).\n");
1820 halbtc8821a1ant_action_pan_edr(btcoexist
);
1822 case BT_8821A_1ANT_COEX_ALGO_PANHS
:
1823 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1824 "[BTCoex], Action algorithm = HS mode.\n");
1825 halbtc8821a1ant_action_pan_hs(btcoexist
);
1827 case BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP
:
1828 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1829 "[BTCoex], Action algorithm = PAN+A2DP.\n");
1830 halbtc8821a1ant_action_pan_edr_a2dp(btcoexist
);
1832 case BT_8821A_1ANT_COEX_ALGO_PANEDR_HID
:
1833 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1834 "[BTCoex], Action algorithm = PAN(EDR)+HID.\n");
1835 halbtc8821a1ant_action_pan_edr_hid(btcoexist
);
1837 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR
:
1838 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1839 "[BTCoex], Action algorithm = HID+A2DP+PAN.\n");
1840 halbtc8821a1ant_action_hid_a2dp_pan_edr(btcoexist
);
1842 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP
:
1843 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1844 "[BTCoex], Action algorithm = HID+A2DP.\n");
1845 halbtc8821a1ant_action_hid_a2dp(btcoexist
);
1848 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1849 "[BTCoex], Action algorithm = coexist All Off!!\n");
1852 coex_dm
->pre_algorithm
= coex_dm
->cur_algorithm
;
1856 static void halbtc8821a1ant_run_coexist_mechanism(struct btc_coexist
*btcoexist
)
1858 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1859 bool wifi_connected
= false, bt_hs_on
= false;
1860 bool increase_scan_dev_num
= false;
1861 bool bt_ctrl_agg_buf_size
= false;
1862 u8 agg_buf_size
= 5;
1863 u8 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
1864 bool wifi_under_5g
= false;
1866 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1867 "[BTCoex], RunCoexistMechanism() ===>\n");
1869 if (btcoexist
->manual_control
) {
1870 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1871 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
1875 if (btcoexist
->stop_coex_dm
) {
1876 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1877 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
1881 if (coex_sta
->under_ips
) {
1882 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1883 "[BTCoex], wifi is under IPS !!!\n");
1887 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_UNDER_5G
,
1889 if (wifi_under_5g
) {
1890 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
1891 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
1892 halbtc8821a1ant_coex_under_5g(btcoexist
);
1896 if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) ||
1897 (BT_8821A_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
1898 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
)) {
1899 increase_scan_dev_num
= true;
1902 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_INC_SCAN_DEV_NUM
,
1903 &increase_scan_dev_num
);
1905 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
1908 if (!bt_link_info
->sco_exist
&& !bt_link_info
->hid_exist
) {
1909 halbtc8821a1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
1911 if (wifi_connected
) {
1912 wifi_rssi_state
= Wifi_rssi_state(btcoexist
, 1, 2,
1914 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
1915 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
))
1916 halbtc8821a1ant_limited_tx(btcoexist
,
1920 halbtc8821a1ant_limited_tx(btcoexist
,
1924 halbtc8821a1ant_limited_tx(btcoexist
, NORMAL_EXEC
,
1929 if (bt_link_info
->sco_exist
) {
1930 bt_ctrl_agg_buf_size
= true;
1932 } else if (bt_link_info
->hid_exist
) {
1933 bt_ctrl_agg_buf_size
= true;
1935 } else if (bt_link_info
->a2dp_exist
|| bt_link_info
->pan_exist
) {
1936 bt_ctrl_agg_buf_size
= true;
1939 halbtc8821a1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
1940 bt_ctrl_agg_buf_size
, agg_buf_size
);
1942 run_sw_coexist_mechanism(btcoexist
);
1944 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
1945 if (coex_sta
->c2h_bt_inquiry_page
) {
1946 halbtc8821a1ant_action_bt_inquiry(btcoexist
);
1948 } else if (bt_hs_on
) {
1949 halbtc8821a1ant_action_hs(btcoexist
);
1953 if (!wifi_connected
) {
1954 bool scan
= false, link
= false, roam
= false;
1956 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
, "[BTCoex], wifi is non connected-idle !!!\n");
1958 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
1959 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
1960 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
1962 if (scan
|| link
|| roam
)
1963 wifi_not_connected_asso_auth_scan(btcoexist
);
1965 halbtc8821a1ant_action_wifi_not_connected(btcoexist
);
1968 halbtc8821a1ant_action_wifi_connected(btcoexist
);
1972 static void halbtc8821a1ant_init_coex_dm(struct btc_coexist
*btcoexist
)
1974 /* force to reset coex mechanism */
1976 halbtc8821a1ant_sw_mechanism(btcoexist
, false);
1978 halbtc8821a1ant_ps_tdma(btcoexist
, FORCE_EXEC
, false, 8);
1979 halbtc8821a1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 0);
1982 static void halbtc8821a1ant_init_hw_config(struct btc_coexist
*btcoexist
,
1986 bool wifi_under_5g
= false;
1988 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
1989 "[BTCoex], 1Ant Init HW Config!!\n");
1992 coex_dm
->backup_arfr_cnt1
=
1993 btcoexist
->btc_read_4byte(btcoexist
, 0x430);
1994 coex_dm
->backup_arfr_cnt2
=
1995 btcoexist
->btc_read_4byte(btcoexist
, 0x434);
1996 coex_dm
->backup_retry_limit
=
1997 btcoexist
->btc_read_2byte(btcoexist
, 0x42a);
1998 coex_dm
->backup_ampdu_max_time
=
1999 btcoexist
->btc_read_1byte(btcoexist
, 0x456);
2002 /* 0x790[5:0] = 0x5 */
2003 u1_tmp
= btcoexist
->btc_read_1byte(btcoexist
, 0x790);
2006 btcoexist
->btc_write_1byte(btcoexist
, 0x790, u1_tmp
);
2008 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_UNDER_5G
, &wifi_under_5g
);
2010 /* Antenna config */
2012 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_BT
,
2015 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_PTA
,
2018 halbtc8821a1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 0);
2020 /* Enable counter statistics */
2021 /* 0x76e[3] = 1, WLAN_Act control by PTA */
2022 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0xc);
2023 btcoexist
->btc_write_1byte(btcoexist
, 0x778, 0x3);
2024 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x40, 0x20, 0x1);
2028 /* work around function start with wa_halbtc8821a1ant_ */
2031 /* extern function start with EXhalbtc8821a1ant_ */
2034 ex_halbtc8821a1ant_init_hwconfig(
2035 struct btc_coexist
*btcoexist
2038 halbtc8821a1ant_init_hw_config(btcoexist
, true);
2042 ex_halbtc8821a1ant_init_coex_dm(
2043 struct btc_coexist
*btcoexist
2046 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
, "[BTCoex], Coex Mechanism Init!!\n");
2048 btcoexist
->stop_coex_dm
= false;
2050 halbtc8821a1ant_init_coex_dm(btcoexist
);
2052 halbtc8821a1ant_query_bt_info(btcoexist
);
2055 void ex_halbtc8821a1ant_display_coex_info(struct btc_coexist
*btcoexist
)
2057 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
2058 struct btc_stack_info
*stack_info
= &btcoexist
->stack_info
;
2059 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2060 u8
*cli_buf
= btcoexist
->cli_buf
;
2061 u8 u1_tmp
[4], i
, bt_info_ext
, ps_tdma_case
= 0;
2064 bool roam
= false, scan
= false, link
= false, wifi_under_5g
= false;
2065 bool bt_hs_on
= false, wifi_busy
= false;
2066 long wifi_rssi
= 0, bt_hs_rssi
= 0;
2067 u32 wifi_bw
, wifi_traffic_dir
;
2068 u8 wifi_dot11_chnl
, wifi_hs_chnl
;
2069 u32 fw_ver
= 0, bt_patch_ver
= 0;
2071 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2072 "\n ============[BT Coexist info] ============");
2075 if (btcoexist
->manual_control
) {
2076 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2077 "\n ============[Under Manual Control] ============");
2079 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2080 "\n ==========================================");
2083 if (btcoexist
->stop_coex_dm
) {
2084 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2085 "\n ============[Coex is STOPPED] ============");
2087 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2088 "\n ==========================================");
2092 if (!board_info
->bt_exist
) {
2093 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n BT not exists !!!");
2098 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d/ %d/ %d",
2099 "Ant PG Num/ Ant Mech/ Ant Pos: ",
2100 board_info
->pg_ant_num
, board_info
->btdm_ant_num
,
2101 board_info
->btdm_ant_pos
);
2104 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %s / %d",
2105 "BT stack/ hci ext ver",
2106 ((stack_info
->profile_notified
) ? "Yes" : "No"),
2107 stack_info
->hci_version
);
2110 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_BT_PATCH_VER
, &bt_patch_ver
);
2111 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
2112 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2113 "CoexVer/ FwVer/ PatchVer",
2114 glcoex_ver_date_8821a_1ant
, glcoex_ver_8821a_1ant
, fw_ver
,
2115 bt_patch_ver
, bt_patch_ver
);
2118 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2119 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_DOT11_CHNL
,
2121 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_HS_CHNL
, &wifi_hs_chnl
);
2122 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d / %d(%d)",
2123 "Dot11 channel / HsChnl(HsMode)",
2124 wifi_dot11_chnl
, wifi_hs_chnl
, bt_hs_on
);
2127 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %02x %02x %02x ",
2128 "H2C Wifi inform bt chnl Info",
2129 coex_dm
->wifi_chnl_info
[0], coex_dm
->wifi_chnl_info
[1],
2130 coex_dm
->wifi_chnl_info
[2]);
2133 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_WIFI_RSSI
, &wifi_rssi
);
2134 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_HS_RSSI
, &bt_hs_rssi
);
2135 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d/ %d",
2136 "Wifi rssi/ HS rssi",
2137 (int)wifi_rssi
, (int)bt_hs_rssi
);
2140 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
2141 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
2142 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
2143 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d/ %d/ %d ",
2144 "Wifi link/ roam/ scan",
2148 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_UNDER_5G
, &wifi_under_5g
);
2149 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2150 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
2151 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION
,
2153 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %s / %s/ %s ",
2155 (wifi_under_5g
? "5G" : "2.4G"),
2156 ((BTC_WIFI_BW_LEGACY
== wifi_bw
) ? "Legacy" :
2157 (((BTC_WIFI_BW_HT40
== wifi_bw
) ? "HT40" : "HT20"))),
2158 ((!wifi_busy
) ? "idle" :
2159 ((BTC_WIFI_TRAFFIC_TX
== wifi_traffic_dir
) ?
2160 "uplink" : "downlink")));
2162 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2163 "\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]",
2164 ((btcoexist
->bt_info
.bt_disabled
) ? ("disabled") :
2165 ((coex_sta
->c2h_bt_inquiry_page
) ? ("inquiry/page scan") :
2166 ((BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE
==
2167 coex_dm
->bt_status
) ? "non-connected idle" :
2168 ((BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE
==
2169 coex_dm
->bt_status
) ? "connected-idle" : "busy")))),
2170 coex_sta
->bt_rssi
, coex_sta
->bt_retry_cnt
);
2173 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d / %d / %d / %d",
2175 bt_link_info
->sco_exist
, bt_link_info
->hid_exist
,
2176 bt_link_info
->pan_exist
, bt_link_info
->a2dp_exist
);
2178 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_BT_LINK_INFO
);
2180 bt_info_ext
= coex_sta
->bt_info_ext
;
2181 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %s",
2182 "BT Info A2DP rate",
2183 (bt_info_ext
& BIT(0)) ? "Basic rate" : "EDR rate");
2186 for (i
= 0; i
< BT_INFO_SRC_8821A_1ANT_MAX
; i
++) {
2187 if (coex_sta
->bt_info_c2h_cnt
[i
]) {
2188 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2189 "\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)",
2190 glbt_info_src_8821a_1ant
[i
],
2191 coex_sta
->bt_info_c2h
[i
][0],
2192 coex_sta
->bt_info_c2h
[i
][1],
2193 coex_sta
->bt_info_c2h
[i
][2],
2194 coex_sta
->bt_info_c2h
[i
][3],
2195 coex_sta
->bt_info_c2h
[i
][4],
2196 coex_sta
->bt_info_c2h
[i
][5],
2197 coex_sta
->bt_info_c2h
[i
][6],
2198 coex_sta
->bt_info_c2h_cnt
[i
]);
2202 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %s/%s, (0x%x/0x%x)",
2203 "PS state, IPS/LPS, (lps/rpwm)",
2204 ((coex_sta
->under_ips
? "IPS ON" : "IPS OFF")),
2205 ((coex_sta
->under_lps
? "LPS ON" : "LPS OFF")),
2206 btcoexist
->bt_info
.lps_val
,
2207 btcoexist
->bt_info
.rpwm_val
);
2209 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_FW_PWR_MODE_CMD
);
2211 if (!btcoexist
->manual_control
) {
2213 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2214 "\n %-35s", "============[Sw mechanism] ============");
2217 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2218 "\n %-35s = %d", "SM[LowPenaltyRA]",
2219 coex_dm
->cur_low_penalty_ra
);
2222 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2223 "\n %-35s = %s/ %s/ %d ", "DelBA/ BtCtrlAgg/ AggSize",
2224 (btcoexist
->bt_info
.reject_agg_pkt
? "Yes" : "No"),
2225 (btcoexist
->bt_info
.b_bt_ctrl_buf_size
?
2227 btcoexist
->bt_info
.agg_buf_size
);
2229 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2230 "\n %-35s = 0x%x ", "Rate Mask",
2231 btcoexist
->bt_info
.ra_mask
);
2235 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s",
2236 "============[Fw mechanism] ============");
2239 ps_tdma_case
= coex_dm
->cur_ps_tdma
;
2240 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2241 "\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)",
2243 coex_dm
->ps_tdma_para
[0], coex_dm
->ps_tdma_para
[1],
2244 coex_dm
->ps_tdma_para
[2], coex_dm
->ps_tdma_para
[3],
2245 coex_dm
->ps_tdma_para
[4], ps_tdma_case
,
2246 coex_dm
->auto_tdma_adjust
);
2249 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x ",
2250 "Latest error condition(should be 0)",
2251 coex_dm
->error_condition
);
2254 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d ",
2256 coex_dm
->cur_ignore_wlan_act
);
2261 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s",
2262 "============[Hw setting] ============");
2265 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2266 "backup ARFR1/ARFR2/RL/AMaxTime",
2267 coex_dm
->backup_arfr_cnt1
, coex_dm
->backup_arfr_cnt2
,
2268 coex_dm
->backup_retry_limit
, coex_dm
->backup_ampdu_max_time
);
2271 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x430);
2272 u4_tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x434);
2273 u2_tmp
[0] = btcoexist
->btc_read_2byte(btcoexist
, 0x42a);
2274 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x456);
2275 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2276 "0x430/0x434/0x42a/0x456",
2277 u4_tmp
[0], u4_tmp
[1], u2_tmp
[0], u1_tmp
[0]);
2280 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x778);
2281 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xc58);
2282 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2283 "\n %-35s = 0x%x/ 0x%x", "0x778/ 0xc58[29:25]",
2284 u1_tmp
[0], (u4_tmp
[0]&0x3e000000) >> 25);
2287 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x8db);
2288 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x", "0x8db[6:5]",
2289 ((u1_tmp
[0]&0x60)>>5));
2292 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x975);
2293 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xcb4);
2294 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2295 "0xcb4[29:28]/0xcb4[7:0]/0x974[9:8]",
2296 (u4_tmp
[0]&0x30000000)>>28, u4_tmp
[0]&0xff, u1_tmp
[0] & 0x3);
2299 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x40);
2300 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
2301 u1_tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0x64);
2302 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2303 "0x40/0x4c[24:23]/0x64[0]",
2304 u1_tmp
[0], ((u4_tmp
[0]&0x01800000)>>23), u1_tmp
[1]&0x1);
2307 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x550);
2308 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x522);
2309 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x/ 0x%x",
2310 "0x550(bcn ctrl)/0x522",
2311 u4_tmp
[0], u1_tmp
[0]);
2314 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xc50);
2315 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x", "0xc50(dig)",
2319 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xf48);
2320 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0xa5d);
2321 u1_tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0xa5c);
2322 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = 0x%x/ 0x%x",
2324 u4_tmp
[0], (u1_tmp
[0]<<8) + u1_tmp
[1]);
2327 u4_tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c0);
2328 u4_tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c4);
2329 u4_tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c8);
2330 u1_tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x6cc);
2331 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
,
2332 "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2333 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
2334 u4_tmp
[0], u4_tmp
[1], u4_tmp
[2], u1_tmp
[0]);
2337 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d/ %d",
2338 "0x770(high-pri rx/tx)",
2339 coex_sta
->high_priority_rx
, coex_sta
->high_priority_tx
);
2341 CL_SPRINTF(cli_buf
, BT_TMP_BUF_SIZE
, "\n %-35s = %d/ %d",
2342 "0x774(low-pri rx/tx)",
2343 coex_sta
->low_priority_rx
, coex_sta
->low_priority_tx
);
2345 #if (BT_AUTO_REPORT_ONLY_8821A_1ANT == 1)
2346 halbtc8821a1ant_monitor_bt_ctr(btcoexist
);
2348 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_COEX_STATISTICS
);
2351 void ex_halbtc8821a1ant_ips_notify(struct btc_coexist
*btcoexist
, u8 type
)
2353 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
)
2356 if (BTC_IPS_ENTER
== type
) {
2357 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2358 "[BTCoex], IPS ENTER notify\n");
2359 coex_sta
->under_ips
= true;
2360 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_BT
,
2362 /* set PTA control */
2363 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
2364 halbtc8821a1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
2365 } else if (BTC_IPS_LEAVE
== type
) {
2366 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2367 "[BTCoex], IPS LEAVE notify\n");
2368 coex_sta
->under_ips
= false;
2370 halbtc8821a1ant_run_coexist_mechanism(btcoexist
);
2374 void ex_halbtc8821a1ant_lps_notify(struct btc_coexist
*btcoexist
, u8 type
)
2376 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
)
2379 if (BTC_LPS_ENABLE
== type
) {
2380 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2381 "[BTCoex], LPS ENABLE notify\n");
2382 coex_sta
->under_lps
= true;
2383 } else if (BTC_LPS_DISABLE
== type
) {
2384 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2385 "[BTCoex], LPS DISABLE notify\n");
2386 coex_sta
->under_lps
= false;
2390 void ex_halbtc8821a1ant_scan_notify(struct btc_coexist
*btcoexist
, u8 type
)
2392 bool wifi_connected
= false, bt_hs_on
= false;
2394 if (btcoexist
->manual_control
||
2395 btcoexist
->stop_coex_dm
||
2396 btcoexist
->bt_info
.bt_disabled
)
2399 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2400 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2403 halbtc8821a1ant_query_bt_info(btcoexist
);
2405 if (coex_sta
->c2h_bt_inquiry_page
) {
2406 halbtc8821a1ant_action_bt_inquiry(btcoexist
);
2408 } else if (bt_hs_on
) {
2409 halbtc8821a1ant_action_hs(btcoexist
);
2413 if (BTC_SCAN_START
== type
) {
2414 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2415 "[BTCoex], SCAN START notify\n");
2416 if (!wifi_connected
) {
2417 /* non-connected scan */
2418 wifi_not_connected_asso_auth_scan(btcoexist
);
2420 /* wifi is connected */
2421 halbtc8821a1ant_action_wifi_connected_scan(btcoexist
);
2423 } else if (BTC_SCAN_FINISH
== type
) {
2424 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2425 "[BTCoex], SCAN FINISH notify\n");
2426 if (!wifi_connected
) /* non-connected scan */
2427 halbtc8821a1ant_action_wifi_not_connected(btcoexist
);
2429 halbtc8821a1ant_action_wifi_connected(btcoexist
);
2433 void ex_halbtc8821a1ant_connect_notify(struct btc_coexist
*btcoexist
, u8 type
)
2435 bool wifi_connected
= false, bt_hs_on
= false;
2437 if (btcoexist
->manual_control
||
2438 btcoexist
->stop_coex_dm
||
2439 btcoexist
->bt_info
.bt_disabled
)
2442 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2443 if (coex_sta
->c2h_bt_inquiry_page
) {
2444 halbtc8821a1ant_action_bt_inquiry(btcoexist
);
2446 } else if (bt_hs_on
) {
2447 halbtc8821a1ant_action_hs(btcoexist
);
2451 if (BTC_ASSOCIATE_START
== type
) {
2452 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2453 "[BTCoex], CONNECT START notify\n");
2454 wifi_not_connected_asso_auth_scan(btcoexist
);
2455 } else if (BTC_ASSOCIATE_FINISH
== type
) {
2456 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2457 "[BTCoex], CONNECT FINISH notify\n");
2459 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2461 if (!wifi_connected
) /* non-connected scan */
2462 halbtc8821a1ant_action_wifi_not_connected(btcoexist
);
2464 halbtc8821a1ant_action_wifi_connected(btcoexist
);
2468 void ex_halbtc8821a1ant_media_status_notify(struct btc_coexist
*btcoexist
,
2471 u8 h2c_parameter
[3] = {0};
2473 u8 wifi_central_chnl
;
2475 if (btcoexist
->manual_control
||
2476 btcoexist
->stop_coex_dm
||
2477 btcoexist
->bt_info
.bt_disabled
)
2480 if (BTC_MEDIA_CONNECT
== type
)
2481 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2482 "[BTCoex], MEDIA connect notify\n");
2484 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2485 "[BTCoex], MEDIA disconnect notify\n");
2487 /* only 2.4G we need to inform bt the chnl mask */
2488 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_CENTRAL_CHNL
,
2489 &wifi_central_chnl
);
2490 if ((BTC_MEDIA_CONNECT
== type
) &&
2491 (wifi_central_chnl
<= 14)) {
2492 /* h2c_parameter[0] = 0x1; */
2493 h2c_parameter
[0] = 0x0;
2494 h2c_parameter
[1] = wifi_central_chnl
;
2495 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2496 if (BTC_WIFI_BW_HT40
== wifi_bw
)
2497 h2c_parameter
[2] = 0x30;
2499 h2c_parameter
[2] = 0x20;
2502 coex_dm
->wifi_chnl_info
[0] = h2c_parameter
[0];
2503 coex_dm
->wifi_chnl_info
[1] = h2c_parameter
[1];
2504 coex_dm
->wifi_chnl_info
[2] = h2c_parameter
[2];
2506 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE_FW_EXEC
,
2507 "[BTCoex], FW write 0x66 = 0x%x\n",
2508 h2c_parameter
[0]<<16|h2c_parameter
[1]<<8|h2c_parameter
[2]);
2510 btcoexist
->btc_fill_h2c(btcoexist
, 0x66, 3, h2c_parameter
);
2513 void ex_halbtc8821a1ant_special_packet_notify(struct btc_coexist
*btcoexist
,
2516 bool bt_hs_on
= false;
2518 if (btcoexist
->manual_control
||
2519 btcoexist
->stop_coex_dm
||
2520 btcoexist
->bt_info
.bt_disabled
)
2523 coex_sta
->special_pkt_period_cnt
= 0;
2525 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2526 if (coex_sta
->c2h_bt_inquiry_page
) {
2527 halbtc8821a1ant_action_bt_inquiry(btcoexist
);
2529 } else if (bt_hs_on
) {
2530 halbtc8821a1ant_action_hs(btcoexist
);
2534 if (BTC_PACKET_DHCP
== type
||
2535 BTC_PACKET_EAPOL
== type
) {
2536 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2537 "[BTCoex], special Packet(%d) notify\n", type
);
2538 action_wifi_connected_special_packet(btcoexist
);
2542 void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist
*btcoexist
,
2543 u8
*tmp_buf
, u8 length
)
2546 u8 i
, rsp_source
= 0;
2547 bool wifi_connected
= false;
2548 bool bt_busy
= false;
2549 bool wifi_under_5g
= false;
2551 coex_sta
->c2h_bt_info_req_sent
= false;
2553 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_UNDER_5G
, &wifi_under_5g
);
2555 rsp_source
= tmp_buf
[0]&0xf;
2556 if (rsp_source
>= BT_INFO_SRC_8821A_1ANT_MAX
)
2557 rsp_source
= BT_INFO_SRC_8821A_1ANT_WIFI_FW
;
2558 coex_sta
->bt_info_c2h_cnt
[rsp_source
]++;
2560 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2561 "[BTCoex], Bt info[%d], length =%d, hex data =[",
2562 rsp_source
, length
);
2563 for (i
= 0; i
< length
; i
++) {
2564 coex_sta
->bt_info_c2h
[rsp_source
][i
] = tmp_buf
[i
];
2566 bt_info
= tmp_buf
[i
];
2568 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2569 "0x%02x]\n", tmp_buf
[i
]);
2571 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2572 "0x%02x, ", tmp_buf
[i
]);
2575 if (BT_INFO_SRC_8821A_1ANT_WIFI_FW
!= rsp_source
) {
2576 coex_sta
->bt_retry_cnt
= /* [3:0] */
2577 coex_sta
->bt_info_c2h
[rsp_source
][2]&0xf;
2580 coex_sta
->bt_info_c2h
[rsp_source
][3]*2+10;
2582 coex_sta
->bt_info_ext
=
2583 coex_sta
->bt_info_c2h
[rsp_source
][4];
2585 /* Here we need to resend some wifi info to BT */
2586 /* because bt is reset and loss of the info. */
2587 if (coex_sta
->bt_info_ext
& BIT(1)) {
2588 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2589 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
2590 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2593 ex_halbtc8821a1ant_media_status_notify(btcoexist
,
2596 ex_halbtc8821a1ant_media_status_notify(btcoexist
,
2597 BTC_MEDIA_DISCONNECT
);
2600 if ((coex_sta
->bt_info_ext
& BIT(3)) && !wifi_under_5g
) {
2601 if (!btcoexist
->manual_control
&&
2602 !btcoexist
->stop_coex_dm
) {
2603 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2604 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
2605 halbtc8821a1ant_ignore_wlan_act(btcoexist
,
2609 /* BT already NOT ignore Wlan active, do nothing here. */
2611 #if (BT_AUTO_REPORT_ONLY_8821A_1ANT == 0)
2612 if ((coex_sta
->bt_info_ext
& BIT(4))) {
2613 /* BT auto report already enabled, do nothing */
2615 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2616 "[BTCoex], BT ext info bit4 check, set BT to enable Auto Report!!\n");
2617 halbtc8821a1ant_bt_auto_report(btcoexist
,
2623 /* check BIT(2) first ==> check if bt is under inquiry or page scan */
2624 if (bt_info
& BT_INFO_8821A_1ANT_B_INQ_PAGE
)
2625 coex_sta
->c2h_bt_inquiry_page
= true;
2627 coex_sta
->c2h_bt_inquiry_page
= false;
2629 /* set link exist status */
2630 if (!(bt_info
&BT_INFO_8821A_1ANT_B_CONNECTION
)) {
2631 coex_sta
->bt_link_exist
= false;
2632 coex_sta
->pan_exist
= false;
2633 coex_sta
->a2dp_exist
= false;
2634 coex_sta
->hid_exist
= false;
2635 coex_sta
->sco_exist
= false;
2637 /* connection exists */
2638 coex_sta
->bt_link_exist
= true;
2639 if (bt_info
& BT_INFO_8821A_1ANT_B_FTP
)
2640 coex_sta
->pan_exist
= true;
2642 coex_sta
->pan_exist
= false;
2643 if (bt_info
& BT_INFO_8821A_1ANT_B_A2DP
)
2644 coex_sta
->a2dp_exist
= true;
2646 coex_sta
->a2dp_exist
= false;
2647 if (bt_info
& BT_INFO_8821A_1ANT_B_HID
)
2648 coex_sta
->hid_exist
= true;
2650 coex_sta
->hid_exist
= false;
2651 if (bt_info
& BT_INFO_8821A_1ANT_B_SCO_ESCO
)
2652 coex_sta
->sco_exist
= true;
2654 coex_sta
->sco_exist
= false;
2657 halbtc8821a1ant_update_bt_link_info(btcoexist
);
2659 if (!(bt_info
&BT_INFO_8821A_1ANT_B_CONNECTION
)) {
2660 coex_dm
->bt_status
= BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE
;
2661 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2662 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
2663 } else if (bt_info
== BT_INFO_8821A_1ANT_B_CONNECTION
) {
2664 /* connection exists but not busy */
2665 coex_dm
->bt_status
= BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE
;
2666 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2667 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
2668 } else if ((bt_info
&BT_INFO_8821A_1ANT_B_SCO_ESCO
) ||
2669 (bt_info
&BT_INFO_8821A_1ANT_B_SCO_BUSY
)) {
2670 coex_dm
->bt_status
= BT_8821A_1ANT_BT_STATUS_SCO_BUSY
;
2671 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2672 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
2673 } else if (bt_info
&BT_INFO_8821A_1ANT_B_ACL_BUSY
) {
2674 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY
!= coex_dm
->bt_status
)
2675 coex_dm
->auto_tdma_adjust
= false;
2676 coex_dm
->bt_status
= BT_8821A_1ANT_BT_STATUS_ACL_BUSY
;
2677 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2678 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
2680 coex_dm
->bt_status
= BT_8821A_1ANT_BT_STATUS_MAX
;
2681 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2682 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
2685 if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) ||
2686 (BT_8821A_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
2687 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
))
2691 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_TRAFFIC_BUSY
, &bt_busy
);
2693 halbtc8821a1ant_run_coexist_mechanism(btcoexist
);
2696 void ex_halbtc8821a1ant_halt_notify(struct btc_coexist
*btcoexist
)
2698 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
, "[BTCoex], Halt notify\n");
2700 btcoexist
->stop_coex_dm
= true;
2702 halbtc8821a1ant_set_ant_path(btcoexist
, BTC_ANT_PATH_BT
, false, true);
2703 halbtc8821a1ant_ignore_wlan_act(btcoexist
, FORCE_EXEC
, true);
2705 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2707 halbtc8821a1ant_ps_tdma(btcoexist
, FORCE_EXEC
, false, 0);
2709 ex_halbtc8821a1ant_media_status_notify(btcoexist
, BTC_MEDIA_DISCONNECT
);
2712 void ex_halbtc8821a1ant_pnp_notify(struct btc_coexist
*btcoexist
, u8 pnp_state
)
2714 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
, "[BTCoex], Pnp notify\n");
2716 if (BTC_WIFI_PNP_SLEEP
== pnp_state
) {
2717 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2718 "[BTCoex], Pnp notify to SLEEP\n");
2719 btcoexist
->stop_coex_dm
= true;
2720 halbtc8821a1ant_ignore_wlan_act(btcoexist
, FORCE_EXEC
, true);
2721 halbtc8821a1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2723 halbtc8821a1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 9);
2724 } else if (BTC_WIFI_PNP_WAKE_UP
== pnp_state
) {
2725 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_NOTIFY
,
2726 "[BTCoex], Pnp notify to WAKE UP\n");
2727 btcoexist
->stop_coex_dm
= false;
2728 halbtc8821a1ant_init_hw_config(btcoexist
, false);
2729 halbtc8821a1ant_init_coex_dm(btcoexist
);
2730 halbtc8821a1ant_query_bt_info(btcoexist
);
2734 void ex_halbtc8821a1ant_periodical(struct btc_coexist
*btcoexist
)
2736 static u8 dis_ver_info_cnt
;
2737 u32 fw_ver
= 0, bt_patch_ver
= 0;
2738 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
2739 struct btc_stack_info
*stack_info
= &btcoexist
->stack_info
;
2741 BTC_PRINT(BTC_MSG_ALGORITHM
, ALGO_TRACE
,
2742 "[BTCoex], ========================== Periodical ===========================\n");
2744 if (dis_ver_info_cnt
<= 5) {
2745 dis_ver_info_cnt
+= 1;
2746 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
2747 "[BTCoex], ****************************************************************\n");
2748 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
2749 "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
2750 board_info
->pg_ant_num
, board_info
->btdm_ant_num
,
2751 board_info
->btdm_ant_pos
);
2752 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
2753 "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
2754 ((stack_info
->profile_notified
) ? "Yes" : "No"),
2755 stack_info
->hci_version
);
2756 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_BT_PATCH_VER
,
2758 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
2759 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
2760 "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
2761 glcoex_ver_date_8821a_1ant
, glcoex_ver_8821a_1ant
,
2762 fw_ver
, bt_patch_ver
, bt_patch_ver
);
2763 BTC_PRINT(BTC_MSG_INTERFACE
, INTF_INIT
,
2764 "[BTCoex], ****************************************************************\n");
2767 #if (BT_AUTO_REPORT_ONLY_8821A_1ANT == 0)
2768 halbtc8821a1ant_query_bt_info(btcoexist
);
2769 halbtc8821a1ant_monitor_bt_ctr(btcoexist
);
2770 halbtc8821a1ant_monitor_bt_enable_disable(btcoexist
);
2772 if (halbtc8821a1ant_Is_wifi_status_changed(btcoexist
) ||
2773 coex_dm
->auto_tdma_adjust
) {
2774 if (coex_sta
->special_pkt_period_cnt
> 2)
2775 halbtc8821a1ant_run_coexist_mechanism(btcoexist
);
2778 coex_sta
->special_pkt_period_cnt
++;