projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'locks-v3.16' of git://git.samba.org/jlayton/linux into next
[deliverable/linux.git] / drivers / staging / rtl8192ee / btcoexist / halbtc8821a1ant.c
1 /* */
2 /* Description: */
3 /* */
4 /* This file is for RTL8821A Co-exist mechanism */
5 /* */
6 /* History */
7 /* 2012/11/15 Cosa first check in. */
8 /* */
9 /* */
10
11 /* */
12 /* include files */
13 /* */
14 #include "halbt_precomp.h"
15 /* */
16 /* Global variables, these are static variables */
17 /* */
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;
22
23 static const char *const glbt_info_src_8821a_1ant[] = {
24 "BT Info[wifi fw]",
25 "BT Info[bt rsp]",
26 "BT Info[bt auto report]",
27 };
28
29 static u32 glcoex_ver_date_8821a_1ant = 20130816;
30 static u32 glcoex_ver_8821a_1ant = 0x41;
31
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,
35 u8 rssi_thresh1)
36 {
37 long bt_rssi = 0;
38 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
39
40 bt_rssi = coex_sta->bt_rssi;
41
42 if (level_num == 2) {
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");
49 } else {
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");
53 }
54 } else {
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");
59 } else {
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");
63 }
64 }
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;
70 }
71
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");
78 } else {
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");
82 }
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");
93 } else {
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");
97 }
98 } else {
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");
103 } else {
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");
107 }
108 }
109 }
110
111 coex_sta->pre_bt_rssi_state = bt_rssi_state;
112
113 return bt_rssi_state;
114 }
115
116 static u8 Wifi_rssi_state(struct btc_coexist *btcoexist, u8 index,
117 u8 level_num, u8 rssi_thresh,
118 u8 rssi_thresh1)
119 {
120 long wifi_rssi = 0;
121 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
122
123 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
124
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");
133 } else {
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");
138 }
139 } else {
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");
145 } else {
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");
150 }
151 }
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];
157 }
158
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");
169 } else {
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");
174 }
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");
190 } else {
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");
195 }
196 } else {
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");
202 } else {
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");
207 }
208 }
209 }
210
211 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
212
213 return wifi_rssi_state;
214 }
215
216 static void update_ra_mask(struct btc_coexist *btcoexist,
217 bool force_exec, u32 dis_rate_mask)
218 {
219 coex_dm->cur_ra_mask = dis_rate_mask;
220
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);
224 }
225 coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
226 }
227
228 static void auto_rate_fallback_retry(struct btc_coexist *btcoexist,
229 bool force_exec, u8 type)
230 {
231 bool wifi_under_b_mode = false;
232
233 coex_dm->cur_arfr_type = type;
234
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);
242 break;
243 case 1:
244 btcoexist->btc_get(btcoexist,
245 BTC_GET_BL_WIFI_UNDER_B_MODE,
246 &wifi_under_b_mode);
247 if (wifi_under_b_mode) {
248 btcoexist->btc_write_4byte(btcoexist,
249 0x430, 0x0);
250 btcoexist->btc_write_4byte(btcoexist,
251 0x434,
252 0x01010101);
253 } else {
254 btcoexist->btc_write_4byte(btcoexist,
255 0x430, 0x0);
256 btcoexist->btc_write_4byte(btcoexist,
257 0x434,
258 0x04030201);
259 }
260 break;
261 default:
262 break;
263 }
264 }
265
266 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
267 }
268
269 static void halbtc8821a1ant_retry_limit(struct btc_coexist *btcoexist,
270 bool force_exec, u8 type)
271 {
272 coex_dm->cur_retry_limit_type = type;
273
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);
279 break;
280 case 1: /* retry limit = 8 */
281 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
282 break;
283 default:
284 break;
285 }
286 }
287
288 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
289 }
290
291 static void halbtc8821a1ant_ampdu_max_time(struct btc_coexist *btcoexist,
292 bool force_exec, u8 type)
293 {
294 coex_dm->cur_ampdu_time_type = type;
295
296 if (force_exec ||
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);
301 break;
302 case 1: /* AMPDU timw = 0x38 * 32us */
303 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
304 break;
305 default:
306 break;
307 }
308 }
309
310 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
311 }
312
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,
316 u8 ampdu_time_type)
317 {
318 switch (ra_mask_type) {
319 case 0: /* normal mode */
320 update_ra_mask(btcoexist, force_exec, 0x0);
321 break;
322 case 1: /* disable cck 1/2 */
323 update_ra_mask(btcoexist, force_exec, 0x00000003);
324 break;
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);
327 break;
328 default:
329 break;
330 }
331
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);
335 }
336
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,
340 u8 agg_buf_size)
341 {
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;
345
346 /* */
347 /* Rx Aggregation related setting */
348 /* */
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);
356
357 }
358
359 static void halbtc8821a1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
360 {
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;
363
364 reg_hp_tx_rx = 0x770;
365 reg_lp_tx_rx = 0x774;
366
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;
370
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;
374
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;
379
380 /* reset counter */
381 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
382 }
383
384 static void halbtc8821a1ant_query_bt_info(struct btc_coexist *btcoexist)
385 {
386 u8 h2c_parameter[1] = {0};
387
388 coex_sta->c2h_bt_info_req_sent = true;
389
390 h2c_parameter[0] |= BIT(0); /* trigger */
391
392 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
393 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
394 h2c_parameter[0]);
395
396 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
397 }
398
399 static void halbtc8821a1ant_update_bt_link_info(struct btc_coexist *btcoexist)
400 {
401 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
402 bool bt_hs_on = false;
403
404 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
405
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;
411
412 /* work around for HS mode. */
413 if (bt_hs_on) {
414 bt_link_info->pan_exist = true;
415 bt_link_info->bt_link_exist = true;
416 }
417
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;
424 else
425 bt_link_info->sco_only = false;
426
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;
433 else
434 bt_link_info->a2dp_only = false;
435
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;
442 else
443 bt_link_info->pan_only = false;
444
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;
451 else
452 bt_link_info->hid_only = false;
453 }
454
455 static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
456 {
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;
461
462 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
463
464 if (!bt_link_info->bt_link_exist) {
465 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], No BT link exists!!!\n");
466 return algorithm;
467 }
468
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++;
477
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;
482 } else {
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) {
490 if (bt_hs_on) {
491 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = PAN(HS) only\n");
492 algorithm = BT_8821A_1ANT_COEX_ALGO_PANHS;
493 } else {
494 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = PAN(EDR) only\n");
495 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR;
496 }
497 }
498 }
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) {
508 if (bt_hs_on) {
509 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = SCO + PAN(HS)\n");
510 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
511 } else {
512 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
513 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
514 }
515 }
516 } else {
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) {
523 if (bt_hs_on) {
524 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = HID + PAN(HS)\n");
525 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
526 } else {
527 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = HID + PAN(EDR)\n");
528 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
529 }
530 } else if (bt_link_info->pan_exist &&
531 bt_link_info->a2dp_exist) {
532 if (bt_hs_on) {
533 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
534 algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS;
535 } else {
536 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
537 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP;
538 }
539 }
540 }
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) {
549 if (bt_hs_on) {
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;
552 } else {
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;
555 }
556 } else if (bt_link_info->pan_exist &&
557 bt_link_info->a2dp_exist) {
558 if (bt_hs_on) {
559 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
560 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
561 } else {
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;
564 }
565 }
566 } else {
567 if (bt_link_info->hid_exist &&
568 bt_link_info->pan_exist &&
569 bt_link_info->a2dp_exist) {
570 if (bt_hs_on) {
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;
573 } else {
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;
576 }
577 }
578 }
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) {
584 if (bt_hs_on) {
585 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
586 } else {
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;
589 }
590 }
591 }
592 }
593
594 return algorithm;
595 }
596
597 static void halbtc8821a1ant_set_bt_auto_report(struct btc_coexist *btcoexist,
598 bool enable_auto_report)
599 {
600 u8 h2c_parameter[1] = {0};
601
602 h2c_parameter[0] = 0;
603
604 if (enable_auto_report)
605 h2c_parameter[0] |= BIT(0);
606
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!!"),
610 h2c_parameter[0]);
611
612 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
613 }
614
615 static void halbtc8821a1ant_bt_auto_report(struct btc_coexist *btcoexist,
616 bool force_exec,
617 bool enable_auto_report)
618 {
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;
622
623 if (!force_exec) {
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);
626
627 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
628 return;
629 }
630 halbtc8821a1ant_set_bt_auto_report(btcoexist, coex_dm->cur_bt_auto_report);
631
632 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
633 }
634
635 static void set_sw_penalty_tx_rate_adaptive(struct btc_coexist *btcoexist,
636 bool low_penalty_ra)
637 {
638 u8 h2c_parameter[6] = {0};
639
640 h2c_parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
641
642 if (low_penalty_ra) {
643 h2c_parameter[1] |= BIT(0);
644 h2c_parameter[2] = 0x00; /* normal rate except MCS7/6/5,
645 * OFDM54/48/36 */
646 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
647 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
648 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
649 }
650
651 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
652 "[BTCoex], set WiFi Low-Penalty Retry: %s",
653 (low_penalty_ra ? "ON!!" : "OFF!!"));
654
655 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
656 }
657
658 static void halbtc8821a1ant_low_penalty_ra(struct btc_coexist *btcoexist,
659 bool force_exec, bool low_penalty_ra)
660 {
661 coex_dm->cur_low_penalty_ra = low_penalty_ra;
662
663 if (!force_exec) {
664 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
665 return;
666 }
667 set_sw_penalty_tx_rate_adaptive(btcoexist, coex_dm->cur_low_penalty_ra);
668
669 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
670 }
671
672 static void halbtc8821a1ant_set_coex_table(struct btc_coexist *btcoexist,
673 u32 val0x6c0, u32 val0x6c4,
674 u32 val0x6c8, u8 val0x6cc)
675 {
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);
679
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);
683
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);
687
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);
691 }
692
693 static void halbtc8821a1ant_coex_table(struct btc_coexist *btcoexist,
694 bool force_exec, u32 val0x6c0,
695 u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
696 {
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,
700 val0x6c8, val0x6cc);
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;
705
706 if (!force_exec) {
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))
711 return;
712 }
713 halbtc8821a1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
714 val0x6c8, val0x6cc);
715
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;
720 }
721
722 static void halbtc8821a1ant_coex_table_with_type(struct btc_coexist *btcoexist,
723 bool force_exec, u8 type)
724 {
725 switch (type) {
726 case 0:
727 halbtc8821a1ant_coex_table(btcoexist, force_exec,
728 0x55555555, 0x55555555,
729 0xffffff, 0x3);
730 break;
731 case 1:
732 halbtc8821a1ant_coex_table(btcoexist, force_exec,
733 0x55555555, 0x5a5a5a5a,
734 0xffffff, 0x3);
735 break;
736 case 2:
737 halbtc8821a1ant_coex_table(btcoexist, force_exec,
738 0x5a5a5a5a, 0x5a5a5a5a,
739 0xffffff, 0x3);
740 break;
741 case 3:
742 halbtc8821a1ant_coex_table(btcoexist, force_exec,
743 0x55555555, 0xaaaaaaaa,
744 0xffffff, 0x3);
745 break;
746 case 4:
747 halbtc8821a1ant_coex_table(btcoexist, force_exec,
748 0xffffffff, 0xffffffff,
749 0xffffff, 0x3);
750 break;
751 case 5:
752 halbtc8821a1ant_coex_table(btcoexist, force_exec,
753 0x5fff5fff, 0x5fff5fff,
754 0xffffff, 0x3);
755 break;
756 case 6:
757 halbtc8821a1ant_coex_table(btcoexist, force_exec,
758 0x55ff55ff, 0x5a5a5a5a,
759 0xffffff, 0x3);
760 break;
761 case 7:
762 halbtc8821a1ant_coex_table(btcoexist, force_exec,
763 0x5afa5afa, 0x5afa5afa,
764 0xffffff, 0x3);
765 break;
766 default:
767 break;
768 }
769 }
770
771 static void halbtc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
772 bool enable)
773 {
774 u8 h2c_parameter[1] = {0};
775
776 if (enable)
777 h2c_parameter[0] |= BIT(0); /* function enable */
778
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",
781 h2c_parameter[0]);
782
783 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
784 }
785
786 static void halbtc8821a1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
787 bool force_exec, bool enable)
788 {
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;
793
794 if (!force_exec) {
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);
799
800 if (coex_dm->pre_ignore_wlan_act ==
801 coex_dm->cur_ignore_wlan_act)
802 return;
803 }
804 halbtc8821a1ant_set_fw_ignore_wlan_act(btcoexist, enable);
805
806 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
807 }
808
809 static void
810 halbtc8821a1ant_set_fw_pstdma(
811 struct btc_coexist *btcoexist,
812 u8 byte1,
813 u8 byte2,
814 u8 byte3,
815 u8 byte4,
816 u8 byte5
817 )
818 {
819 u8 h2c_parameter[5] = {0};
820
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;
826
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;
832
833 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, "[BTCoex], PS-TDMA H2C cmd = 0x%x%08x\n",
834 h2c_parameter[0],
835 h2c_parameter[1]<<24|h2c_parameter[2]<<16|h2c_parameter[3]<<8|h2c_parameter[4]);
836
837 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
838 }
839
840 static void
841 halbtc8821a1ant_set_lps_rpwm(
842 struct btc_coexist *btcoexist,
843 u8 lps_val,
844 u8 rpwm_val
845 )
846 {
847 u8 lps = lps_val;
848 u8 rpwm = rpwm_val;
849
850 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
851 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
852 }
853
854 static void
855 halbtc8821a1ant_lps_rpwm(
856 struct btc_coexist *btcoexist,
857 bool force_exec,
858 u8 lps_val,
859 u8 rpwm_val
860 )
861 {
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;
866
867 if (!force_exec) {
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);
870
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);
875
876 return;
877 }
878 }
879 halbtc8821a1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
880
881 coex_dm->pre_lps = coex_dm->cur_lps;
882 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
883 }
884
885 static void
886 halbtc8821a1ant_sw_mechanism(
887 struct btc_coexist *btcoexist,
888 bool low_penalty_ra
889 )
890 {
891 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
892
893 halbtc8821a1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
894 }
895
896 static void
897 halbtc8821a1ant_set_ant_path(
898 struct btc_coexist *btcoexist,
899 u8 ant_pos_type,
900 bool init_hw_cfg,
901 bool wifi_off
902 )
903 {
904 struct btc_board_info *board_info = &btcoexist->board_info;
905 u32 u4_tmp = 0;
906 u8 h2c_parameter[2] = {0};
907
908 if (init_hw_cfg) {
909 /* 0x4c[23] = 0, 0x4c[24] = 1 Antenna control by WL/BT */
910 u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
911 u4_tmp &= ~BIT(23);
912 u4_tmp |= BIT(24);
913 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
914
915 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x975, 0x3, 0x3);
916 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
917
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);
923
924 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 0x1); /* Main Ant to BT for IPS case 0x4c[23] = 1 */
925 } else {
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);
930
931 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 0x0); /* Aux Ant to BT for IPS case 0x4c[23] = 1 */
932 }
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);
936 u4_tmp &= ~BIT(23);
937 u4_tmp &= ~BIT(24);
938 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
939 }
940
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);
946 else
947 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x2);
948 break;
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);
952 else
953 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x1);
954 break;
955 case BTC_ANT_PATH_PTA:
956 default:
957 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
958 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x1);
959 else
960 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x2);
961 break;
962 }
963 }
964
965 static void
966 halbtc8821a1ant_ps_tdma(
967 struct btc_coexist *btcoexist,
968 bool force_exec,
969 bool turn_on,
970 u8 type
971 )
972 {
973 u8 rssi_adjust_val = 0;
974
975 coex_dm->cur_ps_tdma_on = turn_on;
976 coex_dm->cur_ps_tdma = type;
977
978 if (!force_exec) {
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);
982 } else {
983 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], ********** TDMA(off, %d) **********\n",
984 coex_dm->cur_ps_tdma);
985 }
986
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))
989 return;
990 }
991 if (turn_on) {
992 switch (type) {
993 default:
994 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x1a, 0x1a, 0x0, 0x50);
995 break;
996 case 1:
997 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x3a, 0x03, 0x10, 0x50);
998 rssi_adjust_val = 11;
999 break;
1000 case 2:
1001 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x2b, 0x03, 0x10, 0x50);
1002 rssi_adjust_val = 14;
1003 break;
1004 case 3:
1005 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x1d, 0x1d, 0x0, 0x10);
1006 break;
1007 case 4:
1008 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x93, 0x15, 0x3, 0x14, 0x0);
1009 rssi_adjust_val = 17;
1010 break;
1011 case 5:
1012 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x61, 0x15, 0x3, 0x11, 0x10);
1013 break;
1014 case 6:
1015 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x13, 0xa, 0x3, 0x0, 0x0);
1016 break;
1017 case 7:
1018 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x13, 0xc, 0x5, 0x0, 0x0);
1019 break;
1020 case 8:
1021 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x93, 0x25, 0x3, 0x10, 0x0);
1022 break;
1023 case 9:
1024 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x21, 0x3, 0x10, 0x50);
1025 rssi_adjust_val = 18;
1026 break;
1027 case 10:
1028 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x13, 0xa, 0xa, 0x0, 0x40);
1029 break;
1030 case 11:
1031 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x14, 0x03, 0x10, 0x10);
1032 rssi_adjust_val = 20;
1033 break;
1034 case 12:
1035 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x0a, 0x0a, 0x0, 0x50);
1036 break;
1037 case 13:
1038 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x18, 0x18, 0x0, 0x10);
1039 break;
1040 case 14:
1041 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x21, 0x3, 0x10, 0x10);
1042 break;
1043 case 15:
1044 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x13, 0xa, 0x3, 0x8, 0x0);
1045 break;
1046 case 16:
1047 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x93, 0x15, 0x3, 0x10, 0x0);
1048 rssi_adjust_val = 18;
1049 break;
1050 case 18:
1051 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x93, 0x25, 0x3, 0x10, 0x0);
1052 rssi_adjust_val = 14;
1053 break;
1054 case 20:
1055 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x61, 0x35, 0x03, 0x11, 0x10);
1056 break;
1057 case 21:
1058 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x61, 0x15, 0x03, 0x11, 0x10);
1059 break;
1060 case 22:
1061 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x61, 0x25, 0x03, 0x11, 0x10);
1062 break;
1063 case 23:
1064 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xe3, 0x25, 0x3, 0x31, 0x18);
1065 rssi_adjust_val = 22;
1066 break;
1067 case 24:
1068 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xe3, 0x15, 0x3, 0x31, 0x18);
1069 rssi_adjust_val = 22;
1070 break;
1071 case 25:
1072 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xe3, 0xa, 0x3, 0x31, 0x18);
1073 rssi_adjust_val = 22;
1074 break;
1075 case 26:
1076 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xe3, 0xa, 0x3, 0x31, 0x18);
1077 rssi_adjust_val = 22;
1078 break;
1079 case 27:
1080 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xe3, 0x25, 0x3, 0x31, 0x98);
1081 rssi_adjust_val = 22;
1082 break;
1083 case 28:
1084 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x69, 0x25, 0x3, 0x31, 0x0);
1085 break;
1086 case 29:
1087 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xab, 0x1a, 0x1a, 0x1, 0x10);
1088 break;
1089 case 30:
1090 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x51, 0x14, 0x3, 0x10, 0x50);
1091 break;
1092 case 31:
1093 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xd3, 0x1a, 0x1a, 0, 0x58);
1094 break;
1095 case 32:
1096 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x61, 0xa, 0x3, 0x10, 0x0);
1097 break;
1098 case 33:
1099 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xa3, 0x25, 0x3, 0x30, 0x90);
1100 break;
1101 case 34:
1102 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x53, 0x1a, 0x1a, 0x0, 0x10);
1103 break;
1104 case 35:
1105 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0x63, 0x1a, 0x1a, 0x0, 0x10);
1106 break;
1107 case 36:
1108 halbtc8821a1ant_set_fw_pstdma(btcoexist, 0xd3, 0x12, 0x3, 0x14, 0x50);
1109 break;
1110 }
1111 } else {
1112 /* disable PS tdma */
1113 switch (type) {
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);
1117 break;
1118 case 0:
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);
1122 break;
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);
1126 break;
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);
1130 break;
1131 }
1132 }
1133 rssi_adjust_val = 0;
1134 btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val);
1135
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;
1139 }
1140
1141 static bool
1142 halbtc8821a1ant_is_common_action(
1143 struct btc_coexist *btcoexist
1144 )
1145 {
1146 bool bCommon = false, wifi_connected = false, wifi_busy = false;
1147
1148 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
1149 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1150
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);
1155
1156 bCommon = true;
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);
1161
1162 bCommon = true;
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);
1167
1168 bCommon = true;
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);
1173
1174 bCommon = true;
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);
1179
1180 bCommon = true;
1181 } else {
1182 if (wifi_busy) {
1183 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1184 } else {
1185 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1186 }
1187
1188 bCommon = false;
1189 }
1190
1191 return bCommon;
1192 }
1193
1194 static void
1195 halbtc8821a1ant_tdma_duration_adjust_for_acl(
1196 struct btc_coexist *btcoexist,
1197 u8 wifi_status
1198 )
1199 {
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;
1203
1204 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, "[BTCoex], TdmaDurationAdjustForAcl()\n");
1205
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;
1215
1216 up = 0;
1217 dn = 0;
1218 m = 1;
1219 n = 3;
1220 result = 0;
1221 wait_count = 0;
1222 }
1223 return;
1224 }
1225
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");
1229
1230 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1231 coex_dm->ps_tdma_du_adj_type = 2;
1232 /* */
1233 up = 0;
1234 dn = 0;
1235 m = 1;
1236 n = 3;
1237 result = 0;
1238 wait_count = 0;
1239 } else {
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)); */
1246 result = 0;
1247 wait_count++;
1248
1249 if (retry_count == 0) {
1250 /* no retry in the last 2-second duration */
1251 up++;
1252 dn--;
1253
1254 if (dn <= 0)
1255 dn = 0;
1256
1257 if (up >= n) {
1258 wait_count = 0;
1259 n = 3;
1260 up = 0;
1261 dn = 0;
1262 result = 1;
1263 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], Increase wifi duration!!\n");
1264 }
1265 } else if (retry_count <= 3) {
1266 up--;
1267 dn++;
1268
1269 if (up <= 0)
1270 up = 0;
1271
1272 if (dn == 2) {
1273 if (wait_count <= 2)
1274 m++;
1275 else
1276 m = 1;
1277 if (m >= 20)
1278 m = 20;
1279
1280 n = 3*m;
1281 up = 0;
1282 dn = 0;
1283 wait_count = 0;
1284 result = -1;
1285 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1286 }
1287 } else {
1288 if (wait_count == 1)
1289 m++;
1290 else
1291 m = 1;
1292 if (m >= 20)
1293 m = 20;
1294
1295 n = 3*m;
1296 up = 0;
1297 dn = 0;
1298 wait_count = 0;
1299 result = -1;
1300 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1301 }
1302
1303 if (result == -1) {
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;
1317 }
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;
1332 }
1333 } else {
1334 /* no change */
1335 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, "[BTCoex], ********** TDMA(on, %d) **********\n",
1336 coex_dm->cur_ps_tdma);
1337 }
1338
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);
1345 }
1346 }
1347 }
1348
1349 static void
1350 halbtc8821a1ant_ps_tdma_check_for_power_save_state(
1351 struct btc_coexist *btcoexist,
1352 bool new_ps_state
1353 )
1354 {
1355 u8 lps_mode = 0x0;
1356
1357 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1358
1359 if (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);
1364 }
1365 } else {
1366 /* NO PS state */
1367 if (new_ps_state) {
1368 /* will enter LPS state, turn off psTdma first */
1369 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
1370 } else {
1371 /* keep state under NO PS state, do nothing. */
1372 }
1373 }
1374 }
1375
1376 static void
1377 halbtc8821a1ant_power_save_state(
1378 struct btc_coexist *btcoexist,
1379 u8 ps_type,
1380 u8 lps_val,
1381 u8 rpwm_val
1382 )
1383 {
1384 bool low_pwr_disable = false;
1385
1386 switch (ps_type) {
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);
1392 break;
1393 case BTC_PS_LPS_ON:
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);
1401 break;
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);
1405 break;
1406 default:
1407 break;
1408 }
1409 }
1410
1411 static void
1412 halbtc8821a1ant_coex_under_5g(
1413 struct btc_coexist *btcoexist
1414 )
1415 {
1416 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1417
1418 halbtc8821a1ant_ignore_wlan_act(btcoexist, NORMAL_EXEC, true);
1419
1420 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 10);
1421
1422 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1423
1424 halbtc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1425
1426 halbtc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 5);
1427 }
1428
1429 static void
1430 halbtc8821a1ant_action_wifi_only(
1431 struct btc_coexist *btcoexist
1432 )
1433 {
1434 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1435 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 9);
1436 }
1437
1438 static void
1439 halbtc8821a1ant_monitor_bt_enable_disable(
1440 struct btc_coexist *btcoexist
1441 )
1442 {
1443 static bool pre_bt_disabled;
1444 static u32 bt_disable_cnt;
1445 bool bt_active = true, bt_disabled = false;
1446
1447 /* This function check if bt is disabled */
1448
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) {
1453 bt_active = false;
1454 }
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) {
1459 bt_active = false;
1460 }
1461 if (bt_active) {
1462 bt_disable_cnt = 0;
1463 bt_disabled = false;
1464 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1465 &bt_disabled);
1466 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
1467 "[BTCoex], BT is enabled !!\n");
1468 } else {
1469 bt_disable_cnt++;
1470 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
1471 "[BTCoex], bt all counters = 0, %d times!!\n",
1472 bt_disable_cnt);
1473 if (bt_disable_cnt >= 2) {
1474 bt_disabled = true;
1475 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1476 &bt_disabled);
1477 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
1478 "[BTCoex], BT is disabled !!\n");
1479 halbtc8821a1ant_action_wifi_only(btcoexist);
1480 }
1481 }
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;
1488 if (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);
1493 }
1494 }
1495 }
1496
1497 /* Software Coex Mechanism start */
1498 static void halbtc8821a1ant_action_sco(struct btc_coexist *btcoexist)
1499 {
1500 halbtc8821a1ant_sw_mechanism(btcoexist, true);
1501 }
1502
1503 static void halbtc8821a1ant_action_hid(struct btc_coexist *btcoexist)
1504 {
1505 halbtc8821a1ant_sw_mechanism(btcoexist, true);
1506 }
1507
1508 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
1509 static void halbtc8821a1ant_action_a2dp(struct btc_coexist *btcoexist)
1510 {
1511 halbtc8821a1ant_sw_mechanism(btcoexist, false);
1512 }
1513
1514 static void halbtc8821a1ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
1515 {
1516 halbtc8821a1ant_sw_mechanism(btcoexist, false);
1517 }
1518
1519 static void halbtc8821a1ant_action_pan_edr(struct btc_coexist *btcoexist)
1520 {
1521 halbtc8821a1ant_sw_mechanism(btcoexist, false);
1522 }
1523
1524 /* PAN(HS) only */
1525 static void halbtc8821a1ant_action_pan_hs(struct btc_coexist *btcoexist)
1526 {
1527 halbtc8821a1ant_sw_mechanism(btcoexist, false);
1528 }
1529
1530 /* PAN(EDR)+A2DP */
1531 static void halbtc8821a1ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
1532 {
1533 halbtc8821a1ant_sw_mechanism(btcoexist, false);
1534 }
1535
1536 static void halbtc8821a1ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
1537 {
1538 halbtc8821a1ant_sw_mechanism(btcoexist, true);
1539 }
1540
1541 /* HID+A2DP+PAN(EDR) */
1542 static void halbtc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
1543 {
1544 halbtc8821a1ant_sw_mechanism(btcoexist, true);
1545 }
1546
1547 static void halbtc8821a1ant_action_hid_a2dp(struct btc_coexist *btcoexist)
1548 {
1549 halbtc8821a1ant_sw_mechanism(btcoexist, true);
1550 }
1551
1552 /* Non-Software Coex Mechanism start */
1553 static void halbtc8821a1ant_action_hs(struct btc_coexist *btcoexist)
1554 {
1555 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1556 halbtc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
1557 }
1558
1559 static void halbtc8821a1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1560 {
1561 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1562 bool wifi_connected = false;
1563
1564 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
1565
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);
1576 } else {
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);
1580 }
1581 }
1582
1583 static void
1584 halbtc8821a1ant_action_bt_sco_hid_only_busy(
1585 struct btc_coexist *btcoexist,
1586 u8 wifi_status
1587 )
1588 {
1589 /* tdma and coex table */
1590 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1591
1592 if (BT_8821A_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN == wifi_status)
1593 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1594 else
1595 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1596 }
1597
1598 static void action_wifi_connected_bt_acl_busy(struct btc_coexist *btcoexist, u8 wifi_status)
1599 {
1600 u8 bt_rssi_state;
1601
1602 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1603 bt_rssi_state = halbtc8821a1ant_bt_rssi_state(2, 28, 0);
1604
1605 if (bt_link_info->hid_only) {
1606 /* HID */
1607 halbtc8821a1ant_action_bt_sco_hid_only_busy(btcoexist, wifi_status);
1608 coex_dm->auto_tdma_adjust = false;
1609 return;
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;
1617 }
1618
1619 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1620 } else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) {
1621 /* HID+A2DP */
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;
1629 }
1630
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;
1644 } else {
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;
1648 }
1649 }
1650
1651 static void
1652 halbtc8821a1ant_action_wifi_not_connected(
1653 struct btc_coexist *btcoexist
1654 )
1655 {
1656 /* power save state */
1657 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1658
1659 /* tdma and coex table */
1660 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1661 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1662 }
1663
1664 static void wifi_not_connected_asso_auth_scan(struct btc_coexist *btcoexist)
1665 {
1666 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1667
1668 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1669 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1670 }
1671
1672 static void
1673 halbtc8821a1ant_action_wifi_connected_scan(
1674 struct btc_coexist *btcoexist
1675 )
1676 {
1677 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1678
1679 /* power save state */
1680 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1681
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);
1687 } else {
1688 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1689 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1690 }
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);
1695 } else {
1696 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1697 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1698 }
1699 }
1700
1701 static void action_wifi_connected_special_packet(struct btc_coexist *btcoexist)
1702 {
1703 bool hs_connecting = false;
1704 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1705
1706 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_CONNECTING, &hs_connecting);
1707
1708 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1709
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);
1715 } else {
1716 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1717 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1718 }
1719 } else {
1720 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1721 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1722 }
1723 }
1724
1725 static void halbtc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist)
1726 {
1727 bool wifi_busy = false;
1728 bool scan = false, link = false, roam = false;
1729 bool under_4way = false;
1730
1731 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], CoexForWifiConnect() ===>\n");
1732
1733 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under_4way);
1734 if (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");
1737 return;
1738 }
1739
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");
1746 return;
1747 }
1748
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);
1752 else
1753 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1754
1755 /* tdma and coex table */
1756 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1757 if (!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);
1765 } else {
1766 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1767 halbtc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1768 }
1769 } else {
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);
1779 } else {
1780 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1781 true, 5);
1782 halbtc8821a1ant_coex_table_with_type(btcoexist,
1783 NORMAL_EXEC, 2);
1784 }
1785 }
1786 }
1787
1788 static void run_sw_coexist_mechanism(struct btc_coexist *btcoexist)
1789 {
1790 u8 algorithm = 0;
1791
1792 algorithm = halbtc8821a1ant_action_algorithm(btcoexist);
1793 coex_dm->cur_algorithm = algorithm;
1794
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);
1801 break;
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);
1806 break;
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);
1811 break;
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);
1816 break;
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);
1821 break;
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);
1826 break;
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);
1831 break;
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);
1836 break;
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);
1841 break;
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);
1846 break;
1847 default:
1848 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1849 "[BTCoex], Action algorithm = coexist All Off!!\n");
1850 break;
1851 }
1852 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
1853 }
1854 }
1855
1856 static void halbtc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
1857 {
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;
1865
1866 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1867 "[BTCoex], RunCoexistMechanism() ===>\n");
1868
1869 if (btcoexist->manual_control) {
1870 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1871 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
1872 return;
1873 }
1874
1875 if (btcoexist->stop_coex_dm) {
1876 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1877 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
1878 return;
1879 }
1880
1881 if (coex_sta->under_ips) {
1882 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1883 "[BTCoex], wifi is under IPS !!!\n");
1884 return;
1885 }
1886
1887 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G,
1888 &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);
1893 return;
1894 }
1895
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;
1900 }
1901
1902 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
1903 &increase_scan_dev_num);
1904
1905 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1906 &wifi_connected);
1907
1908 if (!bt_link_info->sco_exist && !bt_link_info->hid_exist) {
1909 halbtc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1910 } else {
1911 if (wifi_connected) {
1912 wifi_rssi_state = Wifi_rssi_state(btcoexist, 1, 2,
1913 30, 0);
1914 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
1915 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
1916 halbtc8821a1ant_limited_tx(btcoexist,
1917 NORMAL_EXEC, 1, 1,
1918 1, 1);
1919 else
1920 halbtc8821a1ant_limited_tx(btcoexist,
1921 NORMAL_EXEC, 1, 1,
1922 1, 1);
1923 } else {
1924 halbtc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC,
1925 0, 0, 0, 0);
1926 }
1927 }
1928
1929 if (bt_link_info->sco_exist) {
1930 bt_ctrl_agg_buf_size = true;
1931 agg_buf_size = 0x3;
1932 } else if (bt_link_info->hid_exist) {
1933 bt_ctrl_agg_buf_size = true;
1934 agg_buf_size = 0x5;
1935 } else if (bt_link_info->a2dp_exist || bt_link_info->pan_exist) {
1936 bt_ctrl_agg_buf_size = true;
1937 agg_buf_size = 0x8;
1938 }
1939 halbtc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
1940 bt_ctrl_agg_buf_size, agg_buf_size);
1941
1942 run_sw_coexist_mechanism(btcoexist);
1943
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);
1947 return;
1948 } else if (bt_hs_on) {
1949 halbtc8821a1ant_action_hs(btcoexist);
1950 return;
1951 }
1952
1953 if (!wifi_connected) {
1954 bool scan = false, link = false, roam = false;
1955
1956 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], wifi is non connected-idle !!!\n");
1957
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);
1961
1962 if (scan || link || roam)
1963 wifi_not_connected_asso_auth_scan(btcoexist);
1964 else
1965 halbtc8821a1ant_action_wifi_not_connected(btcoexist);
1966 } else {
1967 /* wifi LPS/Busy */
1968 halbtc8821a1ant_action_wifi_connected(btcoexist);
1969 }
1970 }
1971
1972 static void halbtc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
1973 {
1974 /* force to reset coex mechanism */
1975 /* sw all off */
1976 halbtc8821a1ant_sw_mechanism(btcoexist, false);
1977
1978 halbtc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
1979 halbtc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
1980 }
1981
1982 static void halbtc8821a1ant_init_hw_config(struct btc_coexist *btcoexist,
1983 bool back_up)
1984 {
1985 u8 u1_tmp = 0;
1986 bool wifi_under_5g = false;
1987
1988 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
1989 "[BTCoex], 1Ant Init HW Config!!\n");
1990
1991 if (back_up) {
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);
2000 }
2001
2002 /* 0x790[5:0] = 0x5 */
2003 u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
2004 u1_tmp &= 0xc0;
2005 u1_tmp |= 0x5;
2006 btcoexist->btc_write_1byte(btcoexist, 0x790, u1_tmp);
2007
2008 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2009
2010 /* Antenna config */
2011 if (wifi_under_5g)
2012 halbtc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2013 true, false);
2014 else
2015 halbtc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2016 true, false);
2017 /* PTA parameter */
2018 halbtc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2019
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);
2025 }
2026
2027 /* */
2028 /* work around function start with wa_halbtc8821a1ant_ */
2029 /* */
2030 /* */
2031 /* extern function start with EXhalbtc8821a1ant_ */
2032 /* */
2033 void
2034 ex_halbtc8821a1ant_init_hwconfig(
2035 struct btc_coexist *btcoexist
2036 )
2037 {
2038 halbtc8821a1ant_init_hw_config(btcoexist, true);
2039 }
2040
2041 void
2042 ex_halbtc8821a1ant_init_coex_dm(
2043 struct btc_coexist *btcoexist
2044 )
2045 {
2046 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, "[BTCoex], Coex Mechanism Init!!\n");
2047
2048 btcoexist->stop_coex_dm = false;
2049
2050 halbtc8821a1ant_init_coex_dm(btcoexist);
2051
2052 halbtc8821a1ant_query_bt_info(btcoexist);
2053 }
2054
2055 void ex_halbtc8821a1ant_display_coex_info(struct btc_coexist *btcoexist)
2056 {
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;
2062 u16 u2_tmp[4];
2063 u32 u4_tmp[4];
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;
2070
2071 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2072 "\n ============[BT Coexist info] ============");
2073 CL_PRINTF(cli_buf);
2074
2075 if (btcoexist->manual_control) {
2076 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2077 "\n ============[Under Manual Control] ============");
2078 CL_PRINTF(cli_buf);
2079 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2080 "\n ==========================================");
2081 CL_PRINTF(cli_buf);
2082 }
2083 if (btcoexist->stop_coex_dm) {
2084 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2085 "\n ============[Coex is STOPPED] ============");
2086 CL_PRINTF(cli_buf);
2087 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2088 "\n ==========================================");
2089 CL_PRINTF(cli_buf);
2090 }
2091
2092 if (!board_info->bt_exist) {
2093 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\n BT not exists !!!");
2094 CL_PRINTF(cli_buf);
2095 return;
2096 }
2097
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);
2102 CL_PRINTF(cli_buf);
2103
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);
2108 CL_PRINTF(cli_buf);
2109
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);
2116 CL_PRINTF(cli_buf);
2117
2118 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2119 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
2120 &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);
2125 CL_PRINTF(cli_buf);
2126
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]);
2131 CL_PRINTF(cli_buf);
2132
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);
2138 CL_PRINTF(cli_buf);
2139
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",
2145 link, roam, scan);
2146 CL_PRINTF(cli_buf);
2147
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,
2152 &wifi_traffic_dir);
2153 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\n %-35s = %s / %s/ %s ",
2154 "Wifi status",
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")));
2161 CL_PRINTF(cli_buf);
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);
2171 CL_PRINTF(cli_buf);
2172
2173 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\n %-35s = %d / %d / %d / %d",
2174 "SCO/HID/PAN/A2DP",
2175 bt_link_info->sco_exist, bt_link_info->hid_exist,
2176 bt_link_info->pan_exist, bt_link_info->a2dp_exist);
2177 CL_PRINTF(cli_buf);
2178 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
2179
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");
2184 CL_PRINTF(cli_buf);
2185
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]);
2199 CL_PRINTF(cli_buf);
2200 }
2201 }
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);
2208 CL_PRINTF(cli_buf);
2209 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
2210
2211 if (!btcoexist->manual_control) {
2212 /* Sw mechanism */
2213 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2214 "\n %-35s", "============[Sw mechanism] ============");
2215 CL_PRINTF(cli_buf);
2216
2217 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2218 "\n %-35s = %d", "SM[LowPenaltyRA]",
2219 coex_dm->cur_low_penalty_ra);
2220 CL_PRINTF(cli_buf);
2221
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 ?
2226 "Yes" : "No"),
2227 btcoexist->bt_info.agg_buf_size);
2228 CL_PRINTF(cli_buf);
2229 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2230 "\n %-35s = 0x%x ", "Rate Mask",
2231 btcoexist->bt_info.ra_mask);
2232 CL_PRINTF(cli_buf);
2233
2234 /* Fw mechanism */
2235 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\n %-35s",
2236 "============[Fw mechanism] ============");
2237 CL_PRINTF(cli_buf);
2238
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)",
2242 "PS TDMA",
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);
2247 CL_PRINTF(cli_buf);
2248
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);
2252 CL_PRINTF(cli_buf);
2253
2254 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\n %-35s = %d ",
2255 "IgnWlanAct",
2256 coex_dm->cur_ignore_wlan_act);
2257 CL_PRINTF(cli_buf);
2258 }
2259
2260 /* Hw setting */
2261 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\n %-35s",
2262 "============[Hw setting] ============");
2263 CL_PRINTF(cli_buf);
2264
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);
2269 CL_PRINTF(cli_buf);
2270
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]);
2278 CL_PRINTF(cli_buf);
2279
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);
2285 CL_PRINTF(cli_buf);
2286
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));
2290 CL_PRINTF(cli_buf);
2291
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);
2297 CL_PRINTF(cli_buf);
2298
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);
2305 CL_PRINTF(cli_buf);
2306
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]);
2312 CL_PRINTF(cli_buf);
2313
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)",
2316 u4_tmp[0]&0xff);
2317 CL_PRINTF(cli_buf);
2318
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",
2323 "OFDM-FA/ CCK-FA",
2324 u4_tmp[0], (u1_tmp[0]<<8) + u1_tmp[1]);
2325 CL_PRINTF(cli_buf);
2326
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]);
2335 CL_PRINTF(cli_buf);
2336
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);
2340 CL_PRINTF(cli_buf);
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);
2344 CL_PRINTF(cli_buf);
2345 #if (BT_AUTO_REPORT_ONLY_8821A_1ANT == 1)
2346 halbtc8821a1ant_monitor_bt_ctr(btcoexist);
2347 #endif
2348 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
2349 }
2350
2351 void ex_halbtc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
2352 {
2353 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2354 return;
2355
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,
2361 false, true);
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;
2369
2370 halbtc8821a1ant_run_coexist_mechanism(btcoexist);
2371 }
2372 }
2373
2374 void ex_halbtc8821a1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
2375 {
2376 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2377 return;
2378
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;
2387 }
2388 }
2389
2390 void ex_halbtc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
2391 {
2392 bool wifi_connected = false, bt_hs_on = false;
2393
2394 if (btcoexist->manual_control ||
2395 btcoexist->stop_coex_dm ||
2396 btcoexist->bt_info.bt_disabled)
2397 return;
2398
2399 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2400 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2401 &wifi_connected);
2402
2403 halbtc8821a1ant_query_bt_info(btcoexist);
2404
2405 if (coex_sta->c2h_bt_inquiry_page) {
2406 halbtc8821a1ant_action_bt_inquiry(btcoexist);
2407 return;
2408 } else if (bt_hs_on) {
2409 halbtc8821a1ant_action_hs(btcoexist);
2410 return;
2411 }
2412
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);
2419 } else {
2420 /* wifi is connected */
2421 halbtc8821a1ant_action_wifi_connected_scan(btcoexist);
2422 }
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);
2428 else
2429 halbtc8821a1ant_action_wifi_connected(btcoexist);
2430 }
2431 }
2432
2433 void ex_halbtc8821a1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
2434 {
2435 bool wifi_connected = false, bt_hs_on = false;
2436
2437 if (btcoexist->manual_control ||
2438 btcoexist->stop_coex_dm ||
2439 btcoexist->bt_info.bt_disabled)
2440 return;
2441
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);
2445 return;
2446 } else if (bt_hs_on) {
2447 halbtc8821a1ant_action_hs(btcoexist);
2448 return;
2449 }
2450
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");
2458
2459 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2460 &wifi_connected);
2461 if (!wifi_connected) /* non-connected scan */
2462 halbtc8821a1ant_action_wifi_not_connected(btcoexist);
2463 else
2464 halbtc8821a1ant_action_wifi_connected(btcoexist);
2465 }
2466 }
2467
2468 void ex_halbtc8821a1ant_media_status_notify(struct btc_coexist *btcoexist,
2469 u8 type)
2470 {
2471 u8 h2c_parameter[3] = {0};
2472 u32 wifi_bw;
2473 u8 wifi_central_chnl;
2474
2475 if (btcoexist->manual_control ||
2476 btcoexist->stop_coex_dm ||
2477 btcoexist->bt_info.bt_disabled)
2478 return;
2479
2480 if (BTC_MEDIA_CONNECT == type)
2481 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
2482 "[BTCoex], MEDIA connect notify\n");
2483 else
2484 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
2485 "[BTCoex], MEDIA disconnect notify\n");
2486
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;
2498 else
2499 h2c_parameter[2] = 0x20;
2500 }
2501
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];
2505
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]);
2509
2510 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
2511 }
2512
2513 void ex_halbtc8821a1ant_special_packet_notify(struct btc_coexist *btcoexist,
2514 u8 type)
2515 {
2516 bool bt_hs_on = false;
2517
2518 if (btcoexist->manual_control ||
2519 btcoexist->stop_coex_dm ||
2520 btcoexist->bt_info.bt_disabled)
2521 return;
2522
2523 coex_sta->special_pkt_period_cnt = 0;
2524
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);
2528 return;
2529 } else if (bt_hs_on) {
2530 halbtc8821a1ant_action_hs(btcoexist);
2531 return;
2532 }
2533
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);
2539 }
2540 }
2541
2542 void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
2543 u8 *tmp_buf, u8 length)
2544 {
2545 u8 bt_info = 0;
2546 u8 i, rsp_source = 0;
2547 bool wifi_connected = false;
2548 bool bt_busy = false;
2549 bool wifi_under_5g = false;
2550
2551 coex_sta->c2h_bt_info_req_sent = false;
2552
2553 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2554
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]++;
2559
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];
2565 if (i == 1)
2566 bt_info = tmp_buf[i];
2567 if (i == length-1)
2568 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
2569 "0x%02x]\n", tmp_buf[i]);
2570 else
2571 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
2572 "0x%02x, ", tmp_buf[i]);
2573 }
2574
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;
2578
2579 coex_sta->bt_rssi =
2580 coex_sta->bt_info_c2h[rsp_source][3]*2+10;
2581
2582 coex_sta->bt_info_ext =
2583 coex_sta->bt_info_c2h[rsp_source][4];
2584
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,
2591 &wifi_connected);
2592 if (wifi_connected)
2593 ex_halbtc8821a1ant_media_status_notify(btcoexist,
2594 BTC_MEDIA_CONNECT);
2595 else
2596 ex_halbtc8821a1ant_media_status_notify(btcoexist,
2597 BTC_MEDIA_DISCONNECT);
2598 }
2599
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,
2606 FORCE_EXEC, false);
2607 }
2608 } else {
2609 /* BT already NOT ignore Wlan active, do nothing here. */
2610 }
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 */
2614 } else {
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,
2618 FORCE_EXEC, true);
2619 }
2620 #endif
2621 }
2622
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;
2626 else
2627 coex_sta->c2h_bt_inquiry_page = false;
2628
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;
2636 } else {
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;
2641 else
2642 coex_sta->pan_exist = false;
2643 if (bt_info & BT_INFO_8821A_1ANT_B_A2DP)
2644 coex_sta->a2dp_exist = true;
2645 else
2646 coex_sta->a2dp_exist = false;
2647 if (bt_info & BT_INFO_8821A_1ANT_B_HID)
2648 coex_sta->hid_exist = true;
2649 else
2650 coex_sta->hid_exist = false;
2651 if (bt_info & BT_INFO_8821A_1ANT_B_SCO_ESCO)
2652 coex_sta->sco_exist = true;
2653 else
2654 coex_sta->sco_exist = false;
2655 }
2656
2657 halbtc8821a1ant_update_bt_link_info(btcoexist);
2658
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");
2679 } else {
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");
2683 }
2684
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))
2688 bt_busy = true;
2689 else
2690 bt_busy = false;
2691 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2692
2693 halbtc8821a1ant_run_coexist_mechanism(btcoexist);
2694 }
2695
2696 void ex_halbtc8821a1ant_halt_notify(struct btc_coexist *btcoexist)
2697 {
2698 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
2699
2700 btcoexist->stop_coex_dm = true;
2701
2702 halbtc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false, true);
2703 halbtc8821a1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
2704
2705 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2706 0x0, 0x0);
2707 halbtc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
2708
2709 ex_halbtc8821a1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
2710 }
2711
2712 void ex_halbtc8821a1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
2713 {
2714 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Pnp notify\n");
2715
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,
2722 0x0, 0x0);
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);
2731 }
2732 }
2733
2734 void ex_halbtc8821a1ant_periodical(struct btc_coexist *btcoexist)
2735 {
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;
2740
2741 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2742 "[BTCoex], ========================== Periodical ===========================\n");
2743
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,
2757 &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");
2765 }
2766
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);
2771 #else
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);
2776 }
2777
2778 coex_sta->special_pkt_period_cnt++;
2779 #endif
2780 }
Linux kernel - Deliverables
This page took 0.118676 seconds and 6 git commands to generate.