1 /******************************************************************************
2 *
3 * Copyright(c) 2012 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * The full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
16 *
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
21 *
22 * Larry Finger <Larry.Finger@lwfinger.net>
23 *
24 *****************************************************************************/
25
26 /**************************************************************
27 * Description:
28 *
29 * This file is for RTL8821A Co-exist mechanism
30 *
31 * History
32 * 2012/11/15 Cosa first check in.
33 *
34 **************************************************************/
35
36 /**************************************************************
37 * include files
38 **************************************************************/
39 #include "halbt_precomp.h"
40 /**************************************************************
41 * Global variables, these are static variables
42 **************************************************************/
43 static struct coex_dm_8821a_1ant glcoex_dm_8821a_1ant;
44 static struct coex_dm_8821a_1ant *coex_dm = &glcoex_dm_8821a_1ant;
45 static struct coex_sta_8821a_1ant glcoex_sta_8821a_1ant;
46 static struct coex_sta_8821a_1ant *coex_sta = &glcoex_sta_8821a_1ant;
47 static void btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
48 u8 wifi_status);
49
50 static const char *const glbt_info_src_8821a_1ant[] = {
51 "BT Info[wifi fw]",
52 "BT Info[bt rsp]",
53 "BT Info[bt auto report]",
54 };
55
56 static u32 glcoex_ver_date_8821a_1ant = 20130816;
57 static u32 glcoex_ver_8821a_1ant = 0x41;
58
59 /**************************************************************
60 * local function proto type if needed
61 *
62 * local function start with btc8821a1ant_
63 **************************************************************/
btc8821a1ant_bt_rssi_state(struct btc_coexist * btcoexist,u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)64 static u8 btc8821a1ant_bt_rssi_state(struct btc_coexist *btcoexist,
65 u8 level_num, u8 rssi_thresh,
66 u8 rssi_thresh1)
67 {
68 struct rtl_priv *rtlpriv = btcoexist->adapter;
69 long bt_rssi = 0;
70 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
71
72 bt_rssi = coex_sta->bt_rssi;
73
74 if (level_num == 2) {
75 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
76 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
77 if (bt_rssi >= (rssi_thresh +
78 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
79 bt_rssi_state = BTC_RSSI_STATE_HIGH;
80 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
81 "[BTCoex], BT Rssi state switch to High\n");
82 } else {
83 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
84 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
85 "[BTCoex], BT Rssi state stay at Low\n");
86 }
87 } else {
88 if (bt_rssi < rssi_thresh) {
89 bt_rssi_state = BTC_RSSI_STATE_LOW;
90 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
91 "[BTCoex], BT Rssi state switch to Low\n");
92 } else {
93 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
94 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
95 "[BTCoex], BT Rssi state stay at High\n");
96 }
97 }
98 } else if (level_num == 3) {
99 if (rssi_thresh > rssi_thresh1) {
100 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
101 "[BTCoex], BT Rssi thresh error!!\n");
102 return coex_sta->pre_bt_rssi_state;
103 }
104
105 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
106 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
107 if (bt_rssi >= (rssi_thresh +
108 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
109 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
110 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
111 "[BTCoex], BT Rssi state switch to Medium\n");
112 } else {
113 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
114 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
115 "[BTCoex], BT Rssi state stay at Low\n");
116 }
117 } else if ((coex_sta->pre_bt_rssi_state ==
118 BTC_RSSI_STATE_MEDIUM) ||
119 (coex_sta->pre_bt_rssi_state ==
120 BTC_RSSI_STATE_STAY_MEDIUM)) {
121 if (bt_rssi >= (rssi_thresh1 +
122 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
123 bt_rssi_state = BTC_RSSI_STATE_HIGH;
124 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
125 "[BTCoex], BT Rssi state switch to High\n");
126 } else if (bt_rssi < rssi_thresh) {
127 bt_rssi_state = BTC_RSSI_STATE_LOW;
128 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
129 "[BTCoex], BT Rssi state switch to Low\n");
130 } else {
131 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
132 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
133 "[BTCoex], BT Rssi state stay at Medium\n");
134 }
135 } else {
136 if (bt_rssi < rssi_thresh1) {
137 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
138 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
139 "[BTCoex], BT Rssi state switch to Medium\n");
140 } else {
141 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
142 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
143 "[BTCoex], BT Rssi state stay at High\n");
144 }
145 }
146 }
147 coex_sta->pre_bt_rssi_state = bt_rssi_state;
148
149 return bt_rssi_state;
150 }
151
btc8821a1ant_wifi_rssi_state(struct btc_coexist * btcoexist,u8 index,u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)152 static u8 btc8821a1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
153 u8 index, u8 level_num, u8 rssi_thresh,
154 u8 rssi_thresh1)
155 {
156 struct rtl_priv *rtlpriv = btcoexist->adapter;
157 long wifi_rssi = 0;
158 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
159
160 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
161
162 if (level_num == 2) {
163 if ((coex_sta->pre_wifi_rssi_state[index] ==
164 BTC_RSSI_STATE_LOW) ||
165 (coex_sta->pre_wifi_rssi_state[index] ==
166 BTC_RSSI_STATE_STAY_LOW)) {
167 if (wifi_rssi >= (rssi_thresh +
168 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
169 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
170 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
171 "[BTCoex], wifi RSSI state switch to High\n");
172 } else {
173 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
174 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
175 "[BTCoex], wifi RSSI state stay at Low\n");
176 }
177 } else {
178 if (wifi_rssi < rssi_thresh) {
179 wifi_rssi_state = BTC_RSSI_STATE_LOW;
180 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
181 "[BTCoex], wifi RSSI state switch to Low\n");
182 } else {
183 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
184 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
185 "[BTCoex], wifi RSSI state stay at High\n");
186 }
187 }
188 } else if (level_num == 3) {
189 if (rssi_thresh > rssi_thresh1) {
190 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
191 "[BTCoex], wifi RSSI thresh error!!\n");
192 return coex_sta->pre_wifi_rssi_state[index];
193 }
194
195 if ((coex_sta->pre_wifi_rssi_state[index] ==
196 BTC_RSSI_STATE_LOW) ||
197 (coex_sta->pre_wifi_rssi_state[index] ==
198 BTC_RSSI_STATE_STAY_LOW)) {
199 if (wifi_rssi >= (rssi_thresh +
200 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
201 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
202 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
203 "[BTCoex], wifi RSSI state switch to Medium\n");
204 } else {
205 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
206 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
207 "[BTCoex], wifi RSSI state stay at Low\n");
208 }
209 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
210 BTC_RSSI_STATE_MEDIUM) ||
211 (coex_sta->pre_wifi_rssi_state[index] ==
212 BTC_RSSI_STATE_STAY_MEDIUM)) {
213 if (wifi_rssi >= (rssi_thresh1 +
214 BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
215 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
216 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
217 "[BTCoex], wifi RSSI state switch to High\n");
218 } else if (wifi_rssi < rssi_thresh) {
219 wifi_rssi_state = BTC_RSSI_STATE_LOW;
220 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
221 "[BTCoex], wifi RSSI state switch to Low\n");
222 } else {
223 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
224 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
225 "[BTCoex], wifi RSSI state stay at Medium\n");
226 }
227 } else {
228 if (wifi_rssi < rssi_thresh1) {
229 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
230 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
231 "[BTCoex], wifi RSSI state switch to Medium\n");
232 } else {
233 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
234 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
235 "[BTCoex], wifi RSSI state stay at High\n");
236 }
237 }
238 }
239 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
240
241 return wifi_rssi_state;
242 }
243
btc8821a1ant_update_ra_mask(struct btc_coexist * btcoexist,bool force_exec,u32 dis_rate_mask)244 static void btc8821a1ant_update_ra_mask(struct btc_coexist *btcoexist,
245 bool force_exec, u32 dis_rate_mask)
246 {
247 coex_dm->cur_ra_mask = dis_rate_mask;
248
249 if (force_exec ||
250 (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask)) {
251 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
252 &coex_dm->cur_ra_mask);
253 }
254 coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
255 }
256
btc8821a1ant_auto_rate_fb_retry(struct btc_coexist * btcoexist,bool force_exec,u8 type)257 static void btc8821a1ant_auto_rate_fb_retry(struct btc_coexist *btcoexist,
258 bool force_exec, u8 type)
259 {
260 bool wifi_under_b_mode = false;
261
262 coex_dm->cur_arfr_type = type;
263
264 if (force_exec ||
265 (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
266 switch (coex_dm->cur_arfr_type) {
267 case 0: /* normal mode */
268 btcoexist->btc_write_4byte(btcoexist, 0x430,
269 coex_dm->backup_arfr_cnt1);
270 btcoexist->btc_write_4byte(btcoexist, 0x434,
271 coex_dm->backup_arfr_cnt2);
272 break;
273 case 1:
274 btcoexist->btc_get(btcoexist,
275 BTC_GET_BL_WIFI_UNDER_B_MODE,
276 &wifi_under_b_mode);
277 if (wifi_under_b_mode) {
278 btcoexist->btc_write_4byte(btcoexist, 0x430,
279 0x0);
280 btcoexist->btc_write_4byte(btcoexist, 0x434,
281 0x01010101);
282 } else {
283 btcoexist->btc_write_4byte(btcoexist, 0x430,
284 0x0);
285 btcoexist->btc_write_4byte(btcoexist, 0x434,
286 0x04030201);
287 }
288 break;
289 default:
290 break;
291 }
292 }
293
294 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
295 }
296
btc8821a1ant_retry_limit(struct btc_coexist * btcoexist,bool force_exec,u8 type)297 static void btc8821a1ant_retry_limit(struct btc_coexist *btcoexist,
298 bool force_exec, u8 type)
299 {
300 coex_dm->cur_retry_limit_type = type;
301
302 if (force_exec ||
303 (coex_dm->pre_retry_limit_type != coex_dm->cur_retry_limit_type)) {
304 switch (coex_dm->cur_retry_limit_type) {
305 case 0: /* normal mode */
306 btcoexist->btc_write_2byte(btcoexist, 0x42a,
307 coex_dm->backup_retry_limit);
308 break;
309 case 1: /* retry limit = 8 */
310 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
311 break;
312 default:
313 break;
314 }
315 }
316 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
317 }
318
btc8821a1ant_ampdu_max_time(struct btc_coexist * btcoexist,bool force_exec,u8 type)319 static void btc8821a1ant_ampdu_max_time(struct btc_coexist *btcoexist,
320 bool force_exec, u8 type)
321 {
322 coex_dm->cur_ampdu_time_type = type;
323
324 if (force_exec ||
325 (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
326 switch (coex_dm->cur_ampdu_time_type) {
327 case 0: /* normal mode */
328 btcoexist->btc_write_1byte(btcoexist, 0x456,
329 coex_dm->backup_ampdu_max_time);
330 break;
331 case 1: /* AMPDU time = 0x38 * 32us */
332 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
333 break;
334 default:
335 break;
336 }
337 }
338
339 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
340 }
341
btc8821a1ant_limited_tx(struct btc_coexist * btcoexist,bool force_exec,u8 ra_mask_type,u8 arfr_type,u8 retry_limit_type,u8 ampdu_time_type)342 static void btc8821a1ant_limited_tx(struct btc_coexist *btcoexist,
343 bool force_exec, u8 ra_mask_type,
344 u8 arfr_type, u8 retry_limit_type,
345 u8 ampdu_time_type)
346 {
347 switch (ra_mask_type) {
348 case 0: /* normal mode */
349 btc8821a1ant_update_ra_mask(btcoexist, force_exec, 0x0);
350 break;
351 case 1: /* disable cck 1/2 */
352 btc8821a1ant_update_ra_mask(btcoexist, force_exec,
353 0x00000003);
354 break;
355 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
356 btc8821a1ant_update_ra_mask(btcoexist, force_exec,
357 0x0001f1f7);
358 break;
359 default:
360 break;
361 }
362
363 btc8821a1ant_auto_rate_fb_retry(btcoexist, force_exec, arfr_type);
364 btc8821a1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
365 btc8821a1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
366 }
367
btc8821a1ant_limited_rx(struct btc_coexist * btcoexist,bool force_exec,bool rej_ap_agg_pkt,bool bt_ctrl_agg_buf_size,u8 agg_buf_size)368 static void btc8821a1ant_limited_rx(struct btc_coexist *btcoexist,
369 bool force_exec, bool rej_ap_agg_pkt,
370 bool bt_ctrl_agg_buf_size, u8 agg_buf_size)
371 {
372 bool reject_rx_agg = rej_ap_agg_pkt;
373 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
374 u8 rx_agg_size = agg_buf_size;
375
376 /* Rx Aggregation related setting */
377 btcoexist->btc_set(btcoexist,
378 BTC_SET_BL_TO_REJ_AP_AGG_PKT, &reject_rx_agg);
379 /* decide BT control aggregation buf size or not */
380 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
381 &bt_ctrl_rx_agg_size);
382 /* aggregation buf size, only work when BT control Rx agg size */
383 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
384 /* real update aggregation setting */
385 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
386 }
387
btc8821a1ant_monitor_bt_ctr(struct btc_coexist * btcoexist)388 static void btc8821a1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
389 {
390 u32 reg_hp_tx_rx, reg_lp_tx_rx, u4_tmp;
391 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
392
393 reg_hp_tx_rx = 0x770;
394 reg_lp_tx_rx = 0x774;
395
396 u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_tx_rx);
397 reg_hp_tx = u4_tmp & MASKLWORD;
398 reg_hp_rx = (u4_tmp & MASKHWORD) >> 16;
399
400 u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_tx_rx);
401 reg_lp_tx = u4_tmp & MASKLWORD;
402 reg_lp_rx = (u4_tmp & MASKHWORD) >> 16;
403
404 coex_sta->high_priority_tx = reg_hp_tx;
405 coex_sta->high_priority_rx = reg_hp_rx;
406 coex_sta->low_priority_tx = reg_lp_tx;
407 coex_sta->low_priority_rx = reg_lp_rx;
408
409 /* reset counter */
410 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
411 }
412
btc8821a1ant_query_bt_info(struct btc_coexist * btcoexist)413 static void btc8821a1ant_query_bt_info(struct btc_coexist *btcoexist)
414 {
415 struct rtl_priv *rtlpriv = btcoexist->adapter;
416 u8 h2c_parameter[1] = {0};
417
418 coex_sta->c2h_bt_info_req_sent = true;
419
420 h2c_parameter[0] |= BIT0; /* trigger */
421
422 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
423 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
424 h2c_parameter[0]);
425
426 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
427 }
428
btc8821a1ant_update_bt_link_info(struct btc_coexist * btcoexist)429 static void btc8821a1ant_update_bt_link_info(struct btc_coexist *btcoexist)
430 {
431 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
432 bool bt_hs_on = false;
433
434 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
435
436 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
437 bt_link_info->sco_exist = coex_sta->sco_exist;
438 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
439 bt_link_info->pan_exist = coex_sta->pan_exist;
440 bt_link_info->hid_exist = coex_sta->hid_exist;
441
442 /* work around for HS mode */
443 if (bt_hs_on) {
444 bt_link_info->pan_exist = true;
445 bt_link_info->bt_link_exist = true;
446 }
447
448 /* check if Sco only */
449 if (bt_link_info->sco_exist &&
450 !bt_link_info->a2dp_exist &&
451 !bt_link_info->pan_exist &&
452 !bt_link_info->hid_exist)
453 bt_link_info->sco_only = true;
454 else
455 bt_link_info->sco_only = false;
456
457 /* check if A2dp only */
458 if (!bt_link_info->sco_exist &&
459 bt_link_info->a2dp_exist &&
460 !bt_link_info->pan_exist &&
461 !bt_link_info->hid_exist)
462 bt_link_info->a2dp_only = true;
463 else
464 bt_link_info->a2dp_only = false;
465
466 /* check if Pan only */
467 if (!bt_link_info->sco_exist &&
468 !bt_link_info->a2dp_exist &&
469 bt_link_info->pan_exist &&
470 !bt_link_info->hid_exist)
471 bt_link_info->pan_only = true;
472 else
473 bt_link_info->pan_only = false;
474
475 /* check if Hid only */
476 if (!bt_link_info->sco_exist &&
477 !bt_link_info->a2dp_exist &&
478 !bt_link_info->pan_exist &&
479 bt_link_info->hid_exist)
480 bt_link_info->hid_only = true;
481 else
482 bt_link_info->hid_only = false;
483 }
484
btc8821a1ant_action_algorithm(struct btc_coexist * btcoexist)485 static u8 btc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
486 {
487 struct rtl_priv *rtlpriv = btcoexist->adapter;
488 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
489 bool bt_hs_on = false;
490 u8 algorithm = BT_8821A_1ANT_COEX_ALGO_UNDEFINED;
491 u8 num_of_diff_profile = 0;
492
493 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
494
495 if (!bt_link_info->bt_link_exist) {
496 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
497 "[BTCoex], No BT link exists!!!\n");
498 return algorithm;
499 }
500
501 if (bt_link_info->sco_exist)
502 num_of_diff_profile++;
503 if (bt_link_info->hid_exist)
504 num_of_diff_profile++;
505 if (bt_link_info->pan_exist)
506 num_of_diff_profile++;
507 if (bt_link_info->a2dp_exist)
508 num_of_diff_profile++;
509
510 if (num_of_diff_profile == 1) {
511 if (bt_link_info->sco_exist) {
512 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
513 "[BTCoex], BT Profile = SCO only\n");
514 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
515 } else {
516 if (bt_link_info->hid_exist) {
517 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
518 "[BTCoex], BT Profile = HID only\n");
519 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
520 } else if (bt_link_info->a2dp_exist) {
521 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
522 "[BTCoex], BT Profile = A2DP only\n");
523 algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP;
524 } else if (bt_link_info->pan_exist) {
525 if (bt_hs_on) {
526 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
527 DBG_LOUD,
528 "[BTCoex], BT Profile = PAN(HS) only\n");
529 algorithm = BT_8821A_1ANT_COEX_ALGO_PANHS;
530 } else {
531 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
532 DBG_LOUD,
533 "[BTCoex], BT Profile = PAN(EDR) only\n");
534 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR;
535 }
536 }
537 }
538 } else if (num_of_diff_profile == 2) {
539 if (bt_link_info->sco_exist) {
540 if (bt_link_info->hid_exist) {
541 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
542 "[BTCoex], BT Profile = SCO + HID\n");
543 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
544 } else if (bt_link_info->a2dp_exist) {
545 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
546 "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
547 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
548 } else if (bt_link_info->pan_exist) {
549 if (bt_hs_on) {
550 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
551 DBG_LOUD,
552 "[BTCoex], BT Profile = SCO + PAN(HS)\n");
553 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
554 } else {
555 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
556 DBG_LOUD,
557 "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
558 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
559 }
560 }
561 } else {
562 if (bt_link_info->hid_exist &&
563 bt_link_info->a2dp_exist) {
564 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
565 "[BTCoex], BT Profile = HID + A2DP\n");
566 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
567 } else if (bt_link_info->hid_exist &&
568 bt_link_info->pan_exist) {
569 if (bt_hs_on) {
570 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
571 DBG_LOUD,
572 "[BTCoex], BT Profile = HID + PAN(HS)\n");
573 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
574 } else {
575 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
576 DBG_LOUD,
577 "[BTCoex], BT Profile = HID + PAN(EDR)\n");
578 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
579 }
580 } else if (bt_link_info->pan_exist &&
581 bt_link_info->a2dp_exist) {
582 if (bt_hs_on) {
583 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
584 DBG_LOUD,
585 "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
586 algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS;
587 } else {
588 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
589 DBG_LOUD,
590 "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
591 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP;
592 }
593 }
594 }
595 } else if (num_of_diff_profile == 3) {
596 if (bt_link_info->sco_exist) {
597 if (bt_link_info->hid_exist &&
598 bt_link_info->a2dp_exist) {
599 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
600 "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
601 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
602 } else if (bt_link_info->hid_exist &&
603 bt_link_info->pan_exist) {
604 if (bt_hs_on) {
605 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
606 DBG_LOUD,
607 "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
608 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
609 } else {
610 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
611 DBG_LOUD,
612 "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
613 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
614 }
615 } else if (bt_link_info->pan_exist &&
616 bt_link_info->a2dp_exist) {
617 if (bt_hs_on) {
618 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
619 DBG_LOUD,
620 "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
621 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
622 } else {
623 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
624 DBG_LOUD,
625 "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
626 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
627 }
628 }
629 } else {
630 if (bt_link_info->hid_exist &&
631 bt_link_info->pan_exist &&
632 bt_link_info->a2dp_exist) {
633 if (bt_hs_on) {
634 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
635 DBG_LOUD,
636 "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
637 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
638 } else {
639 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
640 DBG_LOUD,
641 "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
642 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
643 }
644 }
645 }
646 } else if (num_of_diff_profile >= 3) {
647 if (bt_link_info->sco_exist) {
648 if (bt_link_info->hid_exist &&
649 bt_link_info->pan_exist &&
650 bt_link_info->a2dp_exist) {
651 if (bt_hs_on) {
652 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
653 DBG_LOUD,
654 "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
655
656 } else {
657 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
658 DBG_LOUD,
659 "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
660 algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
661 }
662 }
663 }
664 }
665 return algorithm;
666 }
667
btc8821a1ant_set_sw_penalty_tx_rate(struct btc_coexist * btcoexist,bool low_penalty_ra)668 static void btc8821a1ant_set_sw_penalty_tx_rate(struct btc_coexist *btcoexist,
669 bool low_penalty_ra)
670 {
671 struct rtl_priv *rtlpriv = btcoexist->adapter;
672 u8 h2c_parameter[6] = {0};
673
674 h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty*/
675
676 if (low_penalty_ra) {
677 h2c_parameter[1] |= BIT0;
678 /* normal rate except MCS7/6/5, OFDM54/48/36 */
679 h2c_parameter[2] = 0x00;
680 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
681 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
682 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
683 }
684
685 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
686 "[BTCoex], set WiFi Low-Penalty Retry: %s",
687 (low_penalty_ra ? "ON!!" : "OFF!!"));
688
689 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
690 }
691
btc8821a1ant_low_penalty_ra(struct btc_coexist * btcoexist,bool force_exec,bool low_penalty_ra)692 static void btc8821a1ant_low_penalty_ra(struct btc_coexist *btcoexist,
693 bool force_exec, bool low_penalty_ra)
694 {
695 coex_dm->cur_low_penalty_ra = low_penalty_ra;
696
697 if (!force_exec) {
698 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
699 return;
700 }
701 btc8821a1ant_set_sw_penalty_tx_rate(btcoexist,
702 coex_dm->cur_low_penalty_ra);
703
704 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
705 }
706
btc8821a1ant_set_coex_table(struct btc_coexist * btcoexist,u32 val0x6c0,u32 val0x6c4,u32 val0x6c8,u8 val0x6cc)707 static void btc8821a1ant_set_coex_table(struct btc_coexist *btcoexist,
708 u32 val0x6c0, u32 val0x6c4,
709 u32 val0x6c8, u8 val0x6cc)
710 {
711 struct rtl_priv *rtlpriv = btcoexist->adapter;
712
713 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
714 "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
715 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
716
717 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
718 "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
719 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
720
721 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
722 "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
723 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
724
725 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
726 "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
727 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
728 }
729
btc8821a1ant_coex_table(struct btc_coexist * btcoexist,bool force_exec,u32 val0x6c0,u32 val0x6c4,u32 val0x6c8,u8 val0x6cc)730 static void btc8821a1ant_coex_table(struct btc_coexist *btcoexist,
731 bool force_exec, u32 val0x6c0, u32 val0x6c4,
732 u32 val0x6c8, u8 val0x6cc)
733 {
734 struct rtl_priv *rtlpriv = btcoexist->adapter;
735
736 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
737 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
738 (force_exec ? "force to" : ""), val0x6c0, val0x6c4,
739 val0x6c8, val0x6cc);
740 coex_dm->cur_val_0x6c0 = val0x6c0;
741 coex_dm->cur_val_0x6c4 = val0x6c4;
742 coex_dm->cur_val_0x6c8 = val0x6c8;
743 coex_dm->cur_val_0x6cc = val0x6cc;
744
745 if (!force_exec) {
746 if ((coex_dm->pre_val_0x6c0 == coex_dm->cur_val_0x6c0) &&
747 (coex_dm->pre_val_0x6c4 == coex_dm->cur_val_0x6c4) &&
748 (coex_dm->pre_val_0x6c8 == coex_dm->cur_val_0x6c8) &&
749 (coex_dm->pre_val_0x6cc == coex_dm->cur_val_0x6cc))
750 return;
751 }
752 btc8821a1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
753 val0x6c8, val0x6cc);
754
755 coex_dm->pre_val_0x6c0 = coex_dm->cur_val_0x6c0;
756 coex_dm->pre_val_0x6c4 = coex_dm->cur_val_0x6c4;
757 coex_dm->pre_val_0x6c8 = coex_dm->cur_val_0x6c8;
758 coex_dm->pre_val_0x6cc = coex_dm->cur_val_0x6cc;
759 }
760
btc8821a1ant_coex_table_with_type(struct btc_coexist * btcoexist,bool force_exec,u8 type)761 static void btc8821a1ant_coex_table_with_type(struct btc_coexist *btcoexist,
762 bool force_exec, u8 type)
763 {
764 switch (type) {
765 case 0:
766 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
767 0x55555555, 0xffffff, 0x3);
768 break;
769 case 1:
770 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
771 0x5a5a5a5a, 0xffffff, 0x3);
772 break;
773 case 2:
774 btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
775 0x5a5a5a5a, 0xffffff, 0x3);
776 break;
777 case 3:
778 btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
779 0xaaaaaaaa, 0xffffff, 0x3);
780 break;
781 case 4:
782 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
783 0x5a5a5a5a, 0xffffff, 0x3);
784 break;
785 case 5:
786 btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
787 0xaaaa5a5a, 0xffffff, 0x3);
788 break;
789 case 6:
790 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
791 0xaaaa5a5a, 0xffffff, 0x3);
792 break;
793 case 7:
794 btc8821a1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
795 0xaaaaaaaa, 0xffffff, 0x3);
796 break;
797 default:
798 break;
799 }
800 }
801
btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist * btcoexist,bool enable)802 static void btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
803 bool enable)
804 {
805 struct rtl_priv *rtlpriv = btcoexist->adapter;
806 u8 h2c_parameter[1] = {0};
807
808 if (enable)
809 h2c_parameter[0] |= BIT0; /* function enable */
810
811 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
812 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
813 h2c_parameter[0]);
814
815 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
816 }
817
btc8821a1ant_ignore_wlan_act(struct btc_coexist * btcoexist,bool force_exec,bool enable)818 static void btc8821a1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
819 bool force_exec, bool enable)
820 {
821 struct rtl_priv *rtlpriv = btcoexist->adapter;
822
823 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
824 "[BTCoex], %s turn Ignore WlanAct %s\n",
825 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
826 coex_dm->cur_ignore_wlan_act = enable;
827
828 if (!force_exec) {
829 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
830 "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
831 coex_dm->pre_ignore_wlan_act,
832 coex_dm->cur_ignore_wlan_act);
833
834 if (coex_dm->pre_ignore_wlan_act ==
835 coex_dm->cur_ignore_wlan_act)
836 return;
837 }
838 btc8821a1ant_set_fw_ignore_wlan_act(btcoexist, enable);
839
840 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
841 }
842
btc8821a1ant_set_fw_ps_tdma(struct btc_coexist * btcoexist,u8 byte1,u8 byte2,u8 byte3,u8 byte4,u8 byte5)843 static void btc8821a1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
844 u8 byte2, u8 byte3, u8 byte4, u8 byte5)
845 {
846 struct rtl_priv *rtlpriv = btcoexist->adapter;
847 u8 h2c_parameter[5] = {0};
848 u8 real_byte1 = byte1, real_byte5 = byte5;
849 bool ap_enable = false;
850
851 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
852 &ap_enable);
853
854 if (ap_enable) {
855 if (byte1 & BIT4 && !(byte1 & BIT5)) {
856 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
857 "[BTCoex], FW for 1Ant AP mode\n");
858 real_byte1 &= ~BIT4;
859 real_byte1 |= BIT5;
860
861 real_byte5 |= BIT5;
862 real_byte5 &= ~BIT6;
863 }
864 }
865
866 h2c_parameter[0] = real_byte1;
867 h2c_parameter[1] = byte2;
868 h2c_parameter[2] = byte3;
869 h2c_parameter[3] = byte4;
870 h2c_parameter[4] = real_byte5;
871
872 coex_dm->ps_tdma_para[0] = real_byte1;
873 coex_dm->ps_tdma_para[1] = byte2;
874 coex_dm->ps_tdma_para[2] = byte3;
875 coex_dm->ps_tdma_para[3] = byte4;
876 coex_dm->ps_tdma_para[4] = real_byte5;
877
878 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
879 "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
880 h2c_parameter[0],
881 h2c_parameter[1] << 24 |
882 h2c_parameter[2] << 16 |
883 h2c_parameter[3] << 8 |
884 h2c_parameter[4]);
885 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
886 }
887
btc8821a1ant_set_lps_rpwm(struct btc_coexist * btcoexist,u8 lps_val,u8 rpwm_val)888 static void btc8821a1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
889 u8 lps_val, u8 rpwm_val)
890 {
891 u8 lps = lps_val;
892 u8 rpwm = rpwm_val;
893
894 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
895 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
896 }
897
btc8821a1ant_lps_rpwm(struct btc_coexist * btcoexist,bool force_exec,u8 lps_val,u8 rpwm_val)898 static void btc8821a1ant_lps_rpwm(struct btc_coexist *btcoexist,
899 bool force_exec, u8 lps_val, u8 rpwm_val)
900 {
901 struct rtl_priv *rtlpriv = btcoexist->adapter;
902
903 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
904 "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
905 (force_exec ? "force to" : ""), lps_val, rpwm_val);
906 coex_dm->cur_lps = lps_val;
907 coex_dm->cur_rpwm = rpwm_val;
908
909 if (!force_exec) {
910 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
911 "[BTCoex], LPS-RxBeaconMode = 0x%x, LPS-RPWM = 0x%x!!\n",
912 coex_dm->cur_lps, coex_dm->cur_rpwm);
913
914 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
915 (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
916 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
917 "[BTCoex], LPS-RPWM_Last = 0x%x, LPS-RPWM_Now = 0x%x!!\n",
918 coex_dm->pre_rpwm, coex_dm->cur_rpwm);
919
920 return;
921 }
922 }
923 btc8821a1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
924
925 coex_dm->pre_lps = coex_dm->cur_lps;
926 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
927 }
928
btc8821a1ant_sw_mechanism(struct btc_coexist * btcoexist,bool low_penalty_ra)929 static void btc8821a1ant_sw_mechanism(struct btc_coexist *btcoexist,
930 bool low_penalty_ra)
931 {
932 struct rtl_priv *rtlpriv = btcoexist->adapter;
933
934 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
935 "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
936
937 btc8821a1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
938 }
939
btc8821a1ant_set_ant_path(struct btc_coexist * btcoexist,u8 ant_pos_type,bool init_hw_cfg,bool wifi_off)940 static void btc8821a1ant_set_ant_path(struct btc_coexist *btcoexist,
941 u8 ant_pos_type, bool init_hw_cfg,
942 bool wifi_off)
943 {
944 struct btc_board_info *board_info = &btcoexist->board_info;
945 u32 u4_tmp = 0;
946 u8 h2c_parameter[2] = {0};
947
948 if (init_hw_cfg) {
949 /* 0x4c[23] = 0, 0x4c[24] = 1 Antenna control by WL/BT */
950 u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
951 u4_tmp &= ~BIT23;
952 u4_tmp |= BIT24;
953 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
954
955 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x975, 0x3, 0x3);
956 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
957
958 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
959 /* tell firmware "antenna inverse"
960 * WRONG firmware antenna control code, need fw to fix
961 */
962 h2c_parameter[0] = 1;
963 h2c_parameter[1] = 1;
964 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
965 h2c_parameter);
966 } else {
967 /* tell firmware "no antenna inverse"
968 * WRONG firmware antenna control code, need fw to fix
969 */
970 h2c_parameter[0] = 0;
971 h2c_parameter[1] = 1;
972 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
973 h2c_parameter);
974 }
975 } else if (wifi_off) {
976 /* 0x4c[24:23] = 00, Set Antenna control
977 * by BT_RFE_CTRL BT Vendor 0xac = 0xf002
978 */
979 u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
980 u4_tmp &= ~BIT23;
981 u4_tmp &= ~BIT24;
982 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
983
984 /* 0x765 = 0x18 */
985 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3);
986 } else {
987 /* 0x765 = 0x0 */
988 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
989 }
990
991 /* ext switch setting */
992 switch (ant_pos_type) {
993 case BTC_ANT_PATH_WIFI:
994 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
995 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
996 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
997 0x30, 0x1);
998 else
999 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1000 0x30, 0x2);
1001 break;
1002 case BTC_ANT_PATH_BT:
1003 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
1004 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1005 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1006 0x30, 0x2);
1007 else
1008 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1009 0x30, 0x1);
1010 break;
1011 default:
1012 case BTC_ANT_PATH_PTA:
1013 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x66);
1014 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1015 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1016 0x30, 0x1);
1017 else
1018 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1019 0x30, 0x2);
1020 break;
1021 }
1022 }
1023
btc8821a1ant_ps_tdma(struct btc_coexist * btcoexist,bool force_exec,bool turn_on,u8 type)1024 static void btc8821a1ant_ps_tdma(struct btc_coexist *btcoexist,
1025 bool force_exec, bool turn_on, u8 type)
1026 {
1027 struct rtl_priv *rtlpriv = btcoexist->adapter;
1028 u8 rssi_adjust_val = 0;
1029
1030 coex_dm->cur_ps_tdma_on = turn_on;
1031 coex_dm->cur_ps_tdma = type;
1032
1033 if (!force_exec) {
1034 if (coex_dm->cur_ps_tdma_on) {
1035 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1036 "[BTCoex], ********** TDMA(on, %d) **********\n",
1037 coex_dm->cur_ps_tdma);
1038 } else {
1039 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1040 "[BTCoex], ********** TDMA(off, %d) **********\n",
1041 coex_dm->cur_ps_tdma);
1042 }
1043 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1044 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1045 return;
1046 }
1047 if (turn_on) {
1048 switch (type) {
1049 default:
1050 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1a,
1051 0x1a, 0x0, 0x50);
1052 break;
1053 case 1:
1054 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x3a,
1055 0x03, 0x10, 0x50);
1056 rssi_adjust_val = 11;
1057 break;
1058 case 2:
1059 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x2b,
1060 0x03, 0x10, 0x50);
1061 rssi_adjust_val = 14;
1062 break;
1063 case 3:
1064 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1d,
1065 0x1d, 0x0, 0x10);
1066 break;
1067 case 4:
1068 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1069 0x3, 0x14, 0x0);
1070 rssi_adjust_val = 17;
1071 break;
1072 case 5:
1073 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x15,
1074 0x3, 0x11, 0x10);
1075 break;
1076 case 6:
1077 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x20,
1078 0x3, 0x11, 0x13);
1079 break;
1080 case 7:
1081 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xc,
1082 0x5, 0x0, 0x0);
1083 break;
1084 case 8:
1085 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1086 0x3, 0x10, 0x0);
1087 break;
1088 case 9:
1089 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x21,
1090 0x3, 0x10, 0x50);
1091 rssi_adjust_val = 18;
1092 break;
1093 case 10:
1094 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1095 0xa, 0x0, 0x40);
1096 break;
1097 case 11:
1098 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x15,
1099 0x03, 0x10, 0x50);
1100 rssi_adjust_val = 20;
1101 break;
1102 case 12:
1103 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x0a,
1104 0x0a, 0x0, 0x50);
1105 break;
1106 case 13:
1107 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x12,
1108 0x12, 0x0, 0x50);
1109 break;
1110 case 14:
1111 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1e,
1112 0x3, 0x10, 0x14);
1113 break;
1114 case 15:
1115 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1116 0x3, 0x8, 0x0);
1117 break;
1118 case 16:
1119 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1120 0x3, 0x10, 0x0);
1121 rssi_adjust_val = 18;
1122 break;
1123 case 18:
1124 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1125 0x3, 0x10, 0x0);
1126 rssi_adjust_val = 14;
1127 break;
1128 case 20:
1129 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x35,
1130 0x03, 0x11, 0x10);
1131 break;
1132 case 21:
1133 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1134 0x03, 0x11, 0x11);
1135 break;
1136 case 22:
1137 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1138 0x03, 0x11, 0x10);
1139 break;
1140 case 23:
1141 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1142 0x3, 0x31, 0x18);
1143 rssi_adjust_val = 22;
1144 break;
1145 case 24:
1146 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1147 0x3, 0x31, 0x18);
1148 rssi_adjust_val = 22;
1149 break;
1150 case 25:
1151 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1152 0x3, 0x31, 0x18);
1153 rssi_adjust_val = 22;
1154 break;
1155 case 26:
1156 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1157 0x3, 0x31, 0x18);
1158 rssi_adjust_val = 22;
1159 break;
1160 case 27:
1161 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1162 0x3, 0x31, 0x98);
1163 rssi_adjust_val = 22;
1164 break;
1165 case 28:
1166 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x69, 0x25,
1167 0x3, 0x31, 0x0);
1168 break;
1169 case 29:
1170 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xab, 0x1a,
1171 0x1a, 0x1, 0x10);
1172 break;
1173 case 30:
1174 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1175 0x3, 0x10, 0x10);
1176 break;
1177 case 31:
1178 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1a,
1179 0x1a, 0, 0x58);
1180 break;
1181 case 32:
1182 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x35,
1183 0x3, 0x11, 0x11);
1184 break;
1185 case 33:
1186 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x25,
1187 0x3, 0x30, 0x90);
1188 break;
1189 case 34:
1190 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x53, 0x1a,
1191 0x1a, 0x0, 0x10);
1192 break;
1193 case 35:
1194 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x63, 0x1a,
1195 0x1a, 0x0, 0x10);
1196 break;
1197 case 36:
1198 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x12,
1199 0x3, 0x14, 0x50);
1200 break;
1201 case 40:
1202 /* SoftAP only with no sta associated, BT disable, TDMA
1203 * mode for power saving
1204 *
1205 * here softap mode screen off will cost 70-80mA for
1206 * phone
1207 */
1208 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x23, 0x18,
1209 0x00, 0x10, 0x24);
1210 break;
1211 case 41:
1212 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x15,
1213 0x3, 0x11, 0x11);
1214 break;
1215 case 42:
1216 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x20,
1217 0x3, 0x11, 0x11);
1218 break;
1219 case 43:
1220 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1221 0x3, 0x10, 0x11);
1222 break;
1223 }
1224 } else {
1225 /* disable PS tdma */
1226 switch (type) {
1227 case 8:
1228 /* PTA Control */
1229 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x8, 0x0, 0x0,
1230 0x0, 0x0);
1231 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1232 false, false);
1233 break;
1234 case 0:
1235 default:
1236 /* Software control, Antenna at BT side */
1237 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1238 0x0, 0x0);
1239 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
1240 false, false);
1241 break;
1242 case 9:
1243 /* Software control, Antenna at WiFi side */
1244 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1245 0x0, 0x0);
1246 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
1247 false, false);
1248 break;
1249 case 10:
1250 /* under 5G */
1251 btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1252 0x8, 0x0);
1253 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
1254 false, false);
1255 break;
1256 }
1257 }
1258 rssi_adjust_val = 0;
1259 btcoexist->btc_set(btcoexist,
1260 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val);
1261
1262 /* update pre state */
1263 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1264 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1265 }
1266
btc8821a1ant_is_common_action(struct btc_coexist * btcoexist)1267 static bool btc8821a1ant_is_common_action(struct btc_coexist *btcoexist)
1268 {
1269 struct rtl_priv *rtlpriv = btcoexist->adapter;
1270 bool common = false, wifi_connected = false, wifi_busy = false;
1271
1272 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1273 &wifi_connected);
1274 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1275
1276 if (!wifi_connected &&
1277 BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1278 coex_dm->bt_status) {
1279 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1280 "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
1281 btc8821a1ant_sw_mechanism(btcoexist, false);
1282
1283 common = true;
1284 } else if (wifi_connected &&
1285 (BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1286 coex_dm->bt_status)) {
1287 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1288 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1289 btc8821a1ant_sw_mechanism(btcoexist, false);
1290
1291 common = true;
1292 } else if (!wifi_connected &&
1293 (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
1294 coex_dm->bt_status)) {
1295 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1296 "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
1297 btc8821a1ant_sw_mechanism(btcoexist, false);
1298
1299 common = true;
1300 } else if (wifi_connected &&
1301 (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
1302 coex_dm->bt_status)) {
1303 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1304 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1305 btc8821a1ant_sw_mechanism(btcoexist, false);
1306
1307 common = true;
1308 } else if (!wifi_connected &&
1309 (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE !=
1310 coex_dm->bt_status)) {
1311 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1312 "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
1313 btc8821a1ant_sw_mechanism(btcoexist, false);
1314
1315 common = true;
1316 } else {
1317 if (wifi_busy) {
1318 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1319 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1320 } else {
1321 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1322 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1323 }
1324
1325 common = false;
1326 }
1327
1328 return common;
1329 }
1330
btc8821a1ant_ps_tdma_check_for_pwr_save(struct btc_coexist * btcoex,bool new_ps_state)1331 static void btc8821a1ant_ps_tdma_check_for_pwr_save(struct btc_coexist *btcoex,
1332 bool new_ps_state)
1333 {
1334 u8 lps_mode = 0x0;
1335
1336 btcoex->btc_get(btcoex, BTC_GET_U1_LPS_MODE, &lps_mode);
1337
1338 if (lps_mode) {
1339 /* already under LPS state */
1340 if (new_ps_state) {
1341 /* keep state under LPS, do nothing */
1342 } else {
1343 /* will leave LPS state, turn off psTdma first */
1344 btc8821a1ant_ps_tdma(btcoex, NORMAL_EXEC, false, 0);
1345 }
1346 } else {
1347 /* NO PS state*/
1348 if (new_ps_state) {
1349 /* will enter LPS state, turn off psTdma first */
1350 btc8821a1ant_ps_tdma(btcoex, NORMAL_EXEC, false, 0);
1351 } else {
1352 /* keep state under NO PS state, do nothing */
1353 }
1354 }
1355 }
1356
btc8821a1ant_power_save_state(struct btc_coexist * btcoexist,u8 ps_type,u8 lps_val,u8 rpwm_val)1357 static void btc8821a1ant_power_save_state(struct btc_coexist *btcoexist,
1358 u8 ps_type, u8 lps_val, u8 rpwm_val)
1359 {
1360 bool low_pwr_disable = false;
1361
1362 switch (ps_type) {
1363 case BTC_PS_WIFI_NATIVE:
1364 /* recover to original 32k low power setting */
1365 low_pwr_disable = false;
1366 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1367 &low_pwr_disable);
1368 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1369 break;
1370 case BTC_PS_LPS_ON:
1371 btc8821a1ant_ps_tdma_check_for_pwr_save(btcoexist,
1372 true);
1373 btc8821a1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1374 rpwm_val);
1375 /* when coex force to enter LPS, do not enter 32k low power */
1376 low_pwr_disable = true;
1377 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1378 &low_pwr_disable);
1379 /* power save must executed before psTdma */
1380 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1381 break;
1382 case BTC_PS_LPS_OFF:
1383 btc8821a1ant_ps_tdma_check_for_pwr_save(btcoexist, false);
1384 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1385 break;
1386 default:
1387 break;
1388 }
1389 }
1390
btc8821a1ant_coex_under_5g(struct btc_coexist * btcoexist)1391 static void btc8821a1ant_coex_under_5g(struct btc_coexist *btcoexist)
1392 {
1393 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1394 0x0, 0x0);
1395 btc8821a1ant_ignore_wlan_act(btcoexist, NORMAL_EXEC, true);
1396
1397 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 10);
1398
1399 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1400
1401 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1402
1403 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 5);
1404 }
1405
1406 /***********************************************
1407 *
1408 * Software Coex Mechanism start
1409 *
1410 ***********************************************/
1411
1412 /* SCO only or SCO+PAN(HS) */
btc8821a1ant_action_sco(struct btc_coexist * btcoexist)1413 static void btc8821a1ant_action_sco(struct btc_coexist *btcoexist)
1414 {
1415 btc8821a1ant_sw_mechanism(btcoexist, true);
1416 }
1417
btc8821a1ant_action_hid(struct btc_coexist * btcoexist)1418 static void btc8821a1ant_action_hid(struct btc_coexist *btcoexist)
1419 {
1420 btc8821a1ant_sw_mechanism(btcoexist, true);
1421 }
1422
1423 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
btc8821a1ant_action_a2dp(struct btc_coexist * btcoexist)1424 static void btc8821a1ant_action_a2dp(struct btc_coexist *btcoexist)
1425 {
1426 btc8821a1ant_sw_mechanism(btcoexist, false);
1427 }
1428
btc8821a1ant_action_a2dp_pan_hs(struct btc_coexist * btcoexist)1429 static void btc8821a1ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
1430 {
1431 btc8821a1ant_sw_mechanism(btcoexist, false);
1432 }
1433
btc8821a1ant_action_pan_edr(struct btc_coexist * btcoexist)1434 static void btc8821a1ant_action_pan_edr(struct btc_coexist *btcoexist)
1435 {
1436 btc8821a1ant_sw_mechanism(btcoexist, false);
1437 }
1438
1439 /* PAN(HS) only */
btc8821a1ant_action_pan_hs(struct btc_coexist * btcoexist)1440 static void btc8821a1ant_action_pan_hs(struct btc_coexist *btcoexist)
1441 {
1442 btc8821a1ant_sw_mechanism(btcoexist, false);
1443 }
1444
1445 /* PAN(EDR)+A2DP */
btc8821a1ant_action_pan_edr_a2dp(struct btc_coexist * btcoexist)1446 static void btc8821a1ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
1447 {
1448 btc8821a1ant_sw_mechanism(btcoexist, false);
1449 }
1450
btc8821a1ant_action_pan_edr_hid(struct btc_coexist * btcoexist)1451 static void btc8821a1ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
1452 {
1453 btc8821a1ant_sw_mechanism(btcoexist, true);
1454 }
1455
1456 /* HID+A2DP+PAN(EDR) */
btc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist * btcoexist)1457 static void btc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
1458 {
1459 btc8821a1ant_sw_mechanism(btcoexist, true);
1460 }
1461
btc8821a1ant_action_hid_a2dp(struct btc_coexist * btcoexist)1462 static void btc8821a1ant_action_hid_a2dp(struct btc_coexist *btcoexist)
1463 {
1464 btc8821a1ant_sw_mechanism(btcoexist, true);
1465 }
1466
1467 /***********************************************
1468 *
1469 * Non-Software Coex Mechanism start
1470 *
1471 ***********************************************/
1472 static
btc8821a1ant_action_wifi_multi_port(struct btc_coexist * btcoexist)1473 void btc8821a1ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
1474 {
1475 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1476
1477 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1478 /* tdma and coex table */
1479 if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) {
1480 if (bt_link_info->a2dp_exist) {
1481 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1482 btc8821a1ant_coex_table_with_type(btcoexist,
1483 NORMAL_EXEC, 1);
1484 } else if (bt_link_info->a2dp_exist &&
1485 bt_link_info->pan_exist) {
1486 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1487 btc8821a1ant_coex_table_with_type(btcoexist,
1488 NORMAL_EXEC, 4);
1489 } else {
1490 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1491 btc8821a1ant_coex_table_with_type(btcoexist,
1492 NORMAL_EXEC, 4);
1493 }
1494 } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1495 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1496 coex_dm->bt_status)) {
1497 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1498 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1499 } else {
1500 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1501 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1502 }
1503 }
1504
1505 static
btc8821a1ant_action_wifi_not_connected_asso_auth(struct btc_coexist * btcoexist)1506 void btc8821a1ant_action_wifi_not_connected_asso_auth(
1507 struct btc_coexist *btcoexist)
1508 {
1509 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1510
1511 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
1512 0x0);
1513
1514 /* tdma and coex table */
1515 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
1516 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1517 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1518 } else if ((bt_link_info->a2dp_exist) || (bt_link_info->pan_exist)) {
1519 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1520 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1521 } else {
1522 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1523 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1524 }
1525 }
1526
1527
btc8821a1ant_action_hs(struct btc_coexist * btcoexist)1528 static void btc8821a1ant_action_hs(struct btc_coexist *btcoexist)
1529 {
1530 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1531 btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
1532 }
1533
btc8821a1ant_action_bt_inquiry(struct btc_coexist * btcoexist)1534 static void btc8821a1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1535 {
1536 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1537 bool wifi_connected = false;
1538 bool ap_enable = false;
1539 bool wifi_busy = false, bt_busy = false;
1540
1541 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1542 &wifi_connected);
1543 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1544 &ap_enable);
1545 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1546 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1547
1548 if (!wifi_connected && !coex_sta->wifi_is_high_pri_task) {
1549 btc8821a1ant_power_save_state(btcoexist,
1550 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1551 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1552 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1553 } else if ((bt_link_info->sco_exist) || (bt_link_info->a2dp_exist) ||
1554 (bt_link_info->hid_only)) {
1555 /* SCO/HID-only busy */
1556 btc8821a1ant_power_save_state(btcoexist,
1557 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1558 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1559 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1560 } else if ((bt_link_info->a2dp_exist) && (bt_link_info->hid_exist)) {
1561 /* A2DP+HID busy */
1562 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1563 0x0, 0x0);
1564 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1565
1566 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1567 } else if ((bt_link_info->pan_exist) || (wifi_busy)) {
1568 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1569 0x0, 0x0);
1570 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1571
1572 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1573 } else {
1574 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1575 0x0, 0x0);
1576 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1577 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1578 }
1579 }
1580
btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist * btcoexist,u8 wifi_status)1581 static void btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
1582 u8 wifi_status)
1583 {
1584 /* tdma and coex table */
1585 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1586
1587 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1588 }
1589
btc8821a1ant_act_wifi_con_bt_acl_busy(struct btc_coexist * btcoexist,u8 wifi_status)1590 static void btc8821a1ant_act_wifi_con_bt_acl_busy(struct btc_coexist *btcoexist,
1591 u8 wifi_status)
1592 {
1593 u8 bt_rssi_state;
1594
1595 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1596
1597 bt_rssi_state = btc8821a1ant_bt_rssi_state(btcoexist, 2, 28, 0);
1598
1599 if (bt_link_info->hid_only) {
1600 /* HID */
1601 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1602 wifi_status);
1603 coex_dm->auto_tdma_adjust = false;
1604 return;
1605 } else if (bt_link_info->a2dp_only) {
1606 /* A2DP */
1607 if (wifi_status == BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1608 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1609 btc8821a1ant_coex_table_with_type(btcoexist,
1610 NORMAL_EXEC, 1);
1611 coex_dm->auto_tdma_adjust = false;
1612 } else if ((bt_rssi_state != BTC_RSSI_STATE_HIGH) &&
1613 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
1614 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1615 btc8821a1ant_coex_table_with_type(btcoexist,
1616 NORMAL_EXEC, 1);
1617 } else {
1618 /* for low BT RSSI */
1619 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1620 btc8821a1ant_coex_table_with_type(btcoexist,
1621 NORMAL_EXEC, 1);
1622 coex_dm->auto_tdma_adjust = false;
1623 }
1624 } else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) {
1625 /* HID+A2DP */
1626 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
1627 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
1628 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1629 true, 14);
1630 coex_dm->auto_tdma_adjust = false;
1631 } else {
1632 /*for low BT RSSI*/
1633 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1634 true, 14);
1635 coex_dm->auto_tdma_adjust = false;
1636 }
1637
1638 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1639 } else if ((bt_link_info->pan_only) ||
1640 (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
1641 /* PAN(OPP, FTP), HID+PAN(OPP, FTP) */
1642 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1643 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
1644 coex_dm->auto_tdma_adjust = false;
1645 } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
1646 (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
1647 bt_link_info->pan_exist)) {
1648 /* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */
1649 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 43);
1650 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1651 coex_dm->auto_tdma_adjust = false;
1652 } else {
1653 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1654 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1655 coex_dm->auto_tdma_adjust = false;
1656 }
1657 }
1658
1659 static
btc8821a1ant_action_wifi_not_connected(struct btc_coexist * btcoexist)1660 void btc8821a1ant_action_wifi_not_connected(struct btc_coexist *btcoexist)
1661 {
1662 /* power save state */
1663 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1664
1665 /* tdma and coex table */
1666 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1667 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1668 }
1669
btc8821a1ant_act_wifi_not_conn_scan(struct btc_coexist * btcoexist)1670 static void btc8821a1ant_act_wifi_not_conn_scan(struct btc_coexist *btcoexist)
1671 {
1672 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1673
1674 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1675
1676 /* tdma and coex table */
1677 if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) {
1678 if (bt_link_info->a2dp_exist) {
1679 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1680 btc8821a1ant_coex_table_with_type(btcoexist,
1681 NORMAL_EXEC, 1);
1682 } else if (bt_link_info->a2dp_exist &&
1683 bt_link_info->pan_exist) {
1684 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1685 btc8821a1ant_coex_table_with_type(btcoexist,
1686 NORMAL_EXEC, 4);
1687 } else {
1688 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1689 btc8821a1ant_coex_table_with_type(btcoexist,
1690 NORMAL_EXEC, 4);
1691 }
1692 } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1693 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1694 coex_dm->bt_status)) {
1695 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1696 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1697 } else {
1698 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1699 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1700 }
1701 }
1702
1703 static
btc8821a1ant_action_wifi_connected_scan(struct btc_coexist * btcoexist)1704 void btc8821a1ant_action_wifi_connected_scan(struct btc_coexist *btcoexist)
1705 {
1706 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1707
1708 /* power save state */
1709 btc8821a1ant_power_save_state(btcoexist,
1710 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1711
1712 /* tdma and coex table */
1713 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1714 if (bt_link_info->a2dp_exist) {
1715 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1716 btc8821a1ant_coex_table_with_type(btcoexist,
1717 NORMAL_EXEC, 1);
1718 } else {
1719 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1720 btc8821a1ant_coex_table_with_type(btcoexist,
1721 NORMAL_EXEC, 4);
1722 }
1723 } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1724 (coex_dm->bt_status ==
1725 BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY)) {
1726 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1727 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1728 } else {
1729 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1730 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1731 }
1732 }
1733
btc8821a1ant_act_wifi_conn_sp_pkt(struct btc_coexist * btcoexist)1734 static void btc8821a1ant_act_wifi_conn_sp_pkt(struct btc_coexist *btcoexist)
1735 {
1736 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1737
1738 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1739 0x0, 0x0);
1740
1741 /* tdma and coex table */
1742 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
1743 (bt_link_info->a2dp_exist)) {
1744 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1745 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1746 }
1747
1748 if ((bt_link_info->hid_exist) && (bt_link_info->a2dp_exist)) {
1749 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1750 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1751 } else if (bt_link_info->pan_exist) {
1752 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1753 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1754 } else {
1755 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1756 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1757 }
1758 }
1759
btc8821a1ant_action_wifi_connected(struct btc_coexist * btcoexist)1760 static void btc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist)
1761 {
1762 struct rtl_priv *rtlpriv = btcoexist->adapter;
1763 bool wifi_busy = false;
1764 bool scan = false, link = false, roam = false;
1765 bool under_4way = false;
1766 bool ap_enable = false;
1767
1768 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1769 "[BTCoex], CoexForWifiConnect()===>\n");
1770
1771 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
1772 &under_4way);
1773 if (under_4way) {
1774 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
1775 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1776 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
1777 return;
1778 }
1779
1780 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1781 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1782 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1783 if (scan || link || roam) {
1784 if (scan)
1785 btc8821a1ant_action_wifi_connected_scan(btcoexist);
1786 else
1787 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
1788
1789 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1790 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
1791 return;
1792 }
1793
1794 /* power save state*/
1795 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1796 &ap_enable);
1797 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1798 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY ==
1799 coex_dm->bt_status && !ap_enable &&
1800 !btcoexist->bt_link_info.hid_only) {
1801 if (!wifi_busy && btcoexist->bt_link_info.a2dp_only)
1802 /* A2DP */
1803 btc8821a1ant_power_save_state(btcoexist,
1804 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1805 else
1806 btc8821a1ant_power_save_state(btcoexist, BTC_PS_LPS_ON,
1807 0x50, 0x4);
1808 } else {
1809 btc8821a1ant_power_save_state(btcoexist,
1810 BTC_PS_WIFI_NATIVE,
1811 0x0, 0x0);
1812 }
1813
1814 /* tdma and coex table */
1815 if (!wifi_busy) {
1816 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1817 btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist,
1818 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1819 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY ==
1820 coex_dm->bt_status) ||
1821 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1822 coex_dm->bt_status)) {
1823 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1824 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1825 } else {
1826 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1827 btc8821a1ant_coex_table_with_type(btcoexist,
1828 NORMAL_EXEC, 2);
1829 }
1830 } else {
1831 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1832 btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist,
1833 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY);
1834 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY ==
1835 coex_dm->bt_status) ||
1836 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1837 coex_dm->bt_status)) {
1838 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1839 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY);
1840 } else {
1841 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1842 btc8821a1ant_coex_table_with_type(btcoexist,
1843 NORMAL_EXEC, 2);
1844 }
1845 }
1846 }
1847
btc8821a1ant_run_sw_coex_mech(struct btc_coexist * btcoexist)1848 static void btc8821a1ant_run_sw_coex_mech(struct btc_coexist *btcoexist)
1849 {
1850 struct rtl_priv *rtlpriv = btcoexist->adapter;
1851 u8 algorithm = 0;
1852
1853 algorithm = btc8821a1ant_action_algorithm(btcoexist);
1854 coex_dm->cur_algorithm = algorithm;
1855
1856 if (!btc8821a1ant_is_common_action(btcoexist)) {
1857 switch (coex_dm->cur_algorithm) {
1858 case BT_8821A_1ANT_COEX_ALGO_SCO:
1859 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1860 "[BTCoex], Action algorithm = SCO\n");
1861 btc8821a1ant_action_sco(btcoexist);
1862 break;
1863 case BT_8821A_1ANT_COEX_ALGO_HID:
1864 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1865 "[BTCoex], Action algorithm = HID\n");
1866 btc8821a1ant_action_hid(btcoexist);
1867 break;
1868 case BT_8821A_1ANT_COEX_ALGO_A2DP:
1869 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1870 "[BTCoex], Action algorithm = A2DP\n");
1871 btc8821a1ant_action_a2dp(btcoexist);
1872 break;
1873 case BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS:
1874 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1875 "[BTCoex], Action algorithm = A2DP+PAN(HS)\n");
1876 btc8821a1ant_action_a2dp_pan_hs(btcoexist);
1877 break;
1878 case BT_8821A_1ANT_COEX_ALGO_PANEDR:
1879 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1880 "[BTCoex], Action algorithm = PAN(EDR)\n");
1881 btc8821a1ant_action_pan_edr(btcoexist);
1882 break;
1883 case BT_8821A_1ANT_COEX_ALGO_PANHS:
1884 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1885 "[BTCoex], Action algorithm = HS mode\n");
1886 btc8821a1ant_action_pan_hs(btcoexist);
1887 break;
1888 case BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP:
1889 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1890 "[BTCoex], Action algorithm = PAN+A2DP\n");
1891 btc8821a1ant_action_pan_edr_a2dp(btcoexist);
1892 break;
1893 case BT_8821A_1ANT_COEX_ALGO_PANEDR_HID:
1894 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1895 "[BTCoex], Action algorithm = PAN(EDR)+HID\n");
1896 btc8821a1ant_action_pan_edr_hid(btcoexist);
1897 break;
1898 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
1899 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1900 "[BTCoex], Action algorithm = HID+A2DP+PAN\n");
1901 btc8821a1ant_action_hid_a2dp_pan_edr(btcoexist);
1902 break;
1903 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP:
1904 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1905 "[BTCoex], Action algorithm = HID+A2DP\n");
1906 btc8821a1ant_action_hid_a2dp(btcoexist);
1907 break;
1908 default:
1909 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1910 "[BTCoex], Action algorithm = coexist All Off!!\n");
1911 /*btc8821a1ant_coex_all_off(btcoexist);*/
1912 break;
1913 }
1914 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
1915 }
1916 }
1917
btc8821a1ant_run_coexist_mechanism(struct btc_coexist * btcoexist)1918 static void btc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
1919 {
1920 struct rtl_priv *rtlpriv = btcoexist->adapter;
1921 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1922 bool wifi_connected = false, bt_hs_on = false;
1923 bool increase_scan_dev_num = false;
1924 bool bt_ctrl_agg_buf_size = false;
1925 u8 agg_buf_size = 5;
1926 u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
1927 u32 wifi_link_status = 0;
1928 u32 num_of_wifi_link = 0;
1929 bool wifi_under_5g = false;
1930
1931 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1932 "[BTCoex], RunCoexistMechanism()===>\n");
1933
1934 if (btcoexist->manual_control) {
1935 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1936 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
1937 return;
1938 }
1939
1940 if (btcoexist->stop_coex_dm) {
1941 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1942 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
1943 return;
1944 }
1945
1946 if (coex_sta->under_ips) {
1947 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1948 "[BTCoex], wifi is under IPS !!!\n");
1949 return;
1950 }
1951
1952 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
1953 if (wifi_under_5g) {
1954 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1955 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
1956 btc8821a1ant_coex_under_5g(btcoexist);
1957 return;
1958 }
1959
1960 if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
1961 (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
1962 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
1963 increase_scan_dev_num = true;
1964
1965 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
1966 &increase_scan_dev_num);
1967
1968 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1969 &wifi_connected);
1970
1971 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
1972 &wifi_link_status);
1973 num_of_wifi_link = wifi_link_status >> 16;
1974 if ((num_of_wifi_link >= 2) ||
1975 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
1976 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1977 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
1978 bt_ctrl_agg_buf_size, agg_buf_size);
1979 btc8821a1ant_action_wifi_multi_port(btcoexist);
1980 return;
1981 }
1982
1983 if (!bt_link_info->sco_exist && !bt_link_info->hid_exist) {
1984 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1985 } else {
1986 if (wifi_connected) {
1987 wifi_rssi_state =
1988 btc8821a1ant_wifi_rssi_state(btcoexist, 1, 2,
1989 30, 0);
1990 btc8821a1ant_limited_tx(btcoexist,
1991 NORMAL_EXEC, 1, 1,
1992 0, 1);
1993 } else {
1994 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC,
1995 0, 0, 0, 0);
1996 }
1997 }
1998
1999 if (bt_link_info->sco_exist) {
2000 bt_ctrl_agg_buf_size = true;
2001 agg_buf_size = 0x3;
2002 } else if (bt_link_info->hid_exist) {
2003 bt_ctrl_agg_buf_size = true;
2004 agg_buf_size = 0x5;
2005 } else if (bt_link_info->a2dp_exist || bt_link_info->pan_exist) {
2006 bt_ctrl_agg_buf_size = true;
2007 agg_buf_size = 0x8;
2008 }
2009 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2010 bt_ctrl_agg_buf_size, agg_buf_size);
2011
2012 btc8821a1ant_run_sw_coex_mech(btcoexist);
2013
2014 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2015 if (coex_sta->c2h_bt_inquiry_page) {
2016 btc8821a1ant_action_bt_inquiry(btcoexist);
2017 return;
2018 } else if (bt_hs_on) {
2019 btc8821a1ant_action_hs(btcoexist);
2020 return;
2021 }
2022
2023 if (!wifi_connected) {
2024 bool scan = false, link = false, roam = false;
2025
2026 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2027 "[BTCoex], wifi is non connected-idle !!!\n");
2028
2029 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2030 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2031 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2032
2033 if (scan || link || roam) {
2034 if (scan)
2035 btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2036 else
2037 btc8821a1ant_action_wifi_not_connected_asso_auth(
2038 btcoexist);
2039 } else {
2040 btc8821a1ant_action_wifi_not_connected(btcoexist);
2041 }
2042 } else {
2043 /* wifi LPS/Busy */
2044 btc8821a1ant_action_wifi_connected(btcoexist);
2045 }
2046 }
2047
btc8821a1ant_init_coex_dm(struct btc_coexist * btcoexist)2048 static void btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
2049 {
2050 /* force to reset coex mechanism
2051 * sw all off
2052 */
2053 btc8821a1ant_sw_mechanism(btcoexist, false);
2054
2055 btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2056 }
2057
btc8821a1ant_init_hw_config(struct btc_coexist * btcoexist,bool back_up,bool wifi_only)2058 static void btc8821a1ant_init_hw_config(struct btc_coexist *btcoexist,
2059 bool back_up, bool wifi_only)
2060 {
2061 struct rtl_priv *rtlpriv = btcoexist->adapter;
2062 u8 u1_tmp = 0;
2063 bool wifi_under_5g = false;
2064
2065 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2066 "[BTCoex], 1Ant Init HW Config!!\n");
2067
2068 if (wifi_only)
2069 return;
2070
2071 if (back_up) {
2072 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
2073 0x430);
2074 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
2075 0x434);
2076 coex_dm->backup_retry_limit =
2077 btcoexist->btc_read_2byte(btcoexist, 0x42a);
2078 coex_dm->backup_ampdu_max_time =
2079 btcoexist->btc_read_1byte(btcoexist, 0x456);
2080 }
2081
2082 /* 0x790[5:0] = 0x5 */
2083 u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
2084 u1_tmp &= 0xc0;
2085 u1_tmp |= 0x5;
2086 btcoexist->btc_write_1byte(btcoexist, 0x790, u1_tmp);
2087
2088 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2089
2090 /* Antenna config */
2091 if (wifi_under_5g)
2092 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2093 true, false);
2094 else
2095 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2096 true, false);
2097 /* PTA parameter */
2098 btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2099
2100 /* Enable counter statistics
2101 * 0x76e[3] =1, WLAN_Act control by PTA
2102 */
2103 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
2104 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
2105 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
2106 }
2107
2108 /**************************************************************
2109 * extern function start with ex_btc8821a1ant_
2110 **************************************************************/
ex_btc8821a1ant_init_hwconfig(struct btc_coexist * btcoexist,bool wifionly)2111 void ex_btc8821a1ant_init_hwconfig(struct btc_coexist *btcoexist, bool wifionly)
2112 {
2113 btc8821a1ant_init_hw_config(btcoexist, true, wifionly);
2114 btcoexist->auto_report_1ant = true;
2115 }
2116
ex_btc8821a1ant_init_coex_dm(struct btc_coexist * btcoexist)2117 void ex_btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
2118 {
2119 struct rtl_priv *rtlpriv = btcoexist->adapter;
2120
2121 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2122 "[BTCoex], Coex Mechanism Init!!\n");
2123
2124 btcoexist->stop_coex_dm = false;
2125
2126 btc8821a1ant_init_coex_dm(btcoexist);
2127
2128 btc8821a1ant_query_bt_info(btcoexist);
2129 }
2130
ex_btc8821a1ant_display_coex_info(struct btc_coexist * btcoexist,struct seq_file * m)2131 void ex_btc8821a1ant_display_coex_info(struct btc_coexist *btcoexist,
2132 struct seq_file *m)
2133 {
2134 struct btc_board_info *board_info = &btcoexist->board_info;
2135 struct btc_stack_info *stack_info = &btcoexist->stack_info;
2136 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2137 u8 u1_tmp[4], i, bt_info_ext, ps_tdma_case = 0;
2138 u16 u2_tmp[4];
2139 u32 u4_tmp[4];
2140 bool roam = false, scan = false, link = false, wifi_under_5g = false;
2141 bool bt_hs_on = false, wifi_busy = false;
2142 long wifi_rssi = 0, bt_hs_rssi = 0;
2143 u32 wifi_bw, wifi_traffic_dir;
2144 u8 wifi_dot11_chnl, wifi_hs_chnl;
2145 u32 fw_ver = 0, bt_patch_ver = 0;
2146
2147 seq_puts(m, "\n ============[BT Coexist info]============");
2148
2149 if (btcoexist->manual_control) {
2150 seq_puts(m, "\n ============[Under Manual Control]============");
2151 seq_puts(m, "\n ==========================================");
2152 }
2153 if (btcoexist->stop_coex_dm) {
2154 seq_puts(m, "\n ============[Coex is STOPPED]============");
2155 seq_puts(m, "\n ==========================================");
2156 }
2157
2158 seq_printf(m, "\n %-35s = %d/ %d/ %d",
2159 "Ant PG Num/ Ant Mech/ Ant Pos:",
2160 board_info->pg_ant_num,
2161 board_info->btdm_ant_num,
2162 board_info->btdm_ant_pos);
2163
2164 seq_printf(m, "\n %-35s = %s / %d", "BT stack/ hci ext ver",
2165 ((stack_info->profile_notified) ? "Yes" : "No"),
2166 stack_info->hci_version);
2167
2168 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
2169 &bt_patch_ver);
2170 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2171 seq_printf(m, "\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2172 "CoexVer/ FwVer/ PatchVer",
2173 glcoex_ver_date_8821a_1ant,
2174 glcoex_ver_8821a_1ant,
2175 fw_ver, bt_patch_ver,
2176 bt_patch_ver);
2177
2178 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION,
2179 &bt_hs_on);
2180 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
2181 &wifi_dot11_chnl);
2182 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL,
2183 &wifi_hs_chnl);
2184 seq_printf(m, "\n %-35s = %d / %d(%d)",
2185 "Dot11 channel / HsChnl(HsMode)",
2186 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
2187
2188 seq_printf(m, "\n %-35s = %3ph ",
2189 "H2C Wifi inform bt chnl Info",
2190 coex_dm->wifi_chnl_info);
2191
2192 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
2193 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
2194 seq_printf(m, "\n %-35s = %d/ %d", "Wifi rssi/ HS rssi",
2195 (int)wifi_rssi, (int)bt_hs_rssi);
2196
2197 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2198 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2199 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2200 seq_printf(m, "\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
2201 link, roam, scan);
2202
2203 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G,
2204 &wifi_under_5g);
2205 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2206 &wifi_bw);
2207 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
2208 &wifi_busy);
2209 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
2210 &wifi_traffic_dir);
2211 seq_printf(m, "\n %-35s = %s / %s/ %s ", "Wifi status",
2212 (wifi_under_5g ? "5G" : "2.4G"),
2213 ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
2214 (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))),
2215 ((!wifi_busy) ? "idle" :
2216 ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
2217 "uplink" : "downlink")));
2218 seq_printf(m, "\n %-35s = [%s/ %d/ %d] ",
2219 "BT [status/ rssi/ retryCnt]",
2220 ((coex_sta->bt_disabled) ? ("disabled") :
2221 ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") :
2222 ((BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2223 coex_dm->bt_status) ?
2224 "non-connected idle" :
2225 ((BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
2226 coex_dm->bt_status) ?
2227 "connected-idle" : "busy")))),
2228 coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
2229
2230 seq_printf(m, "\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP",
2231 bt_link_info->sco_exist,
2232 bt_link_info->hid_exist,
2233 bt_link_info->pan_exist,
2234 bt_link_info->a2dp_exist);
2235 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO, m);
2236
2237 bt_info_ext = coex_sta->bt_info_ext;
2238 seq_printf(m, "\n %-35s = %s",
2239 "BT Info A2DP rate",
2240 (bt_info_ext & BIT0) ?
2241 "Basic rate" : "EDR rate");
2242
2243 for (i = 0; i < BT_INFO_SRC_8821A_1ANT_MAX; i++) {
2244 if (coex_sta->bt_info_c2h_cnt[i]) {
2245 seq_printf(m, "\n %-35s = %7ph(%d)",
2246 glbt_info_src_8821a_1ant[i],
2247 coex_sta->bt_info_c2h[i],
2248 coex_sta->bt_info_c2h_cnt[i]);
2249 }
2250 }
2251 seq_printf(m, "\n %-35s = %s/%s, (0x%x/0x%x)",
2252 "PS state, IPS/LPS, (lps/rpwm)",
2253 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
2254 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")),
2255 btcoexist->bt_info.lps_val,
2256 btcoexist->bt_info.rpwm_val);
2257 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
2258
2259 if (!btcoexist->manual_control) {
2260 /* Sw mechanism*/
2261 seq_printf(m, "\n %-35s",
2262 "============[Sw mechanism]============");
2263
2264 seq_printf(m, "\n %-35s = %d", "SM[LowPenaltyRA]",
2265 coex_dm->cur_low_penalty_ra);
2266
2267 seq_printf(m, "\n %-35s = %s/ %s/ %d ",
2268 "DelBA/ BtCtrlAgg/ AggSize",
2269 (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"),
2270 (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"),
2271 btcoexist->bt_info.agg_buf_size);
2272 seq_printf(m, "\n %-35s = 0x%x ", "Rate Mask",
2273 btcoexist->bt_info.ra_mask);
2274
2275 /* Fw mechanism */
2276 seq_printf(m, "\n %-35s",
2277 "============[Fw mechanism]============");
2278
2279 ps_tdma_case = coex_dm->cur_ps_tdma;
2280 seq_printf(m, "\n %-35s = %5ph case-%d (auto:%d)",
2281 "PS TDMA",
2282 coex_dm->ps_tdma_para,
2283 ps_tdma_case,
2284 coex_dm->auto_tdma_adjust);
2285
2286 seq_printf(m, "\n %-35s = 0x%x ",
2287 "Latest error condition(should be 0)",
2288 coex_dm->error_condition);
2289
2290 seq_printf(m, "\n %-35s = %d ", "IgnWlanAct",
2291 coex_dm->cur_ignore_wlan_act);
2292 }
2293
2294 /* Hw setting */
2295 seq_printf(m, "\n %-35s", "============[Hw setting]============");
2296
2297 seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2298 "backup ARFR1/ARFR2/RL/AMaxTime",
2299 coex_dm->backup_arfr_cnt1,
2300 coex_dm->backup_arfr_cnt2,
2301 coex_dm->backup_retry_limit,
2302 coex_dm->backup_ampdu_max_time);
2303
2304 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
2305 u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
2306 u2_tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
2307 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
2308 seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2309 "0x430/0x434/0x42a/0x456",
2310 u4_tmp[0], u4_tmp[1], u2_tmp[0], u1_tmp[0]);
2311
2312 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
2313 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc58);
2314 seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "0x778/ 0xc58[29:25]",
2315 u1_tmp[0], (u4_tmp[0] & 0x3e000000) >> 25);
2316
2317 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
2318 seq_printf(m, "\n %-35s = 0x%x", "0x8db[6:5]",
2319 ((u1_tmp[0] & 0x60) >> 5));
2320
2321 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x975);
2322 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
2323 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2324 "0xcb4[29:28]/0xcb4[7:0]/0x974[9:8]",
2325 (u4_tmp[0] & 0x30000000) >> 28,
2326 u4_tmp[0] & 0xff,
2327 u1_tmp[0] & 0x3);
2328
2329 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
2330 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
2331 u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x64);
2332 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2333 "0x40/0x4c[24:23]/0x64[0]",
2334 u1_tmp[0], ((u4_tmp[0] & 0x01800000) >> 23),
2335 u1_tmp[1] & 0x1);
2336
2337 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
2338 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
2339 seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522",
2340 u4_tmp[0], u1_tmp[0]);
2341
2342 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
2343 seq_printf(m, "\n %-35s = 0x%x", "0xc50(dig)",
2344 u4_tmp[0] & 0xff);
2345
2346 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
2347 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5d);
2348 u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
2349 seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "OFDM-FA/ CCK-FA",
2350 u4_tmp[0], (u1_tmp[0] << 8) + u1_tmp[1]);
2351
2352 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
2353 u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
2354 u4_tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
2355 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
2356 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2357 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
2358 u4_tmp[0], u4_tmp[1], u4_tmp[2], u1_tmp[0]);
2359
2360 seq_printf(m, "\n %-35s = %d/ %d", "0x770(high-pri rx/tx)",
2361 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
2362 seq_printf(m, "\n %-35s = %d/ %d", "0x774(low-pri rx/tx)",
2363 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
2364 if (btcoexist->auto_report_1ant)
2365 btc8821a1ant_monitor_bt_ctr(btcoexist);
2366 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
2367 }
2368
ex_btc8821a1ant_ips_notify(struct btc_coexist * btcoexist,u8 type)2369 void ex_btc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
2370 {
2371 struct rtl_priv *rtlpriv = btcoexist->adapter;
2372 bool wifi_under_5g = false;
2373
2374 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2375 return;
2376 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2377 if (wifi_under_5g) {
2378 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2379 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2380 btc8821a1ant_coex_under_5g(btcoexist);
2381 return;
2382 }
2383
2384 if (BTC_IPS_ENTER == type) {
2385 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2386 "[BTCoex], IPS ENTER notify\n");
2387 coex_sta->under_ips = true;
2388 btc8821a1ant_set_ant_path(btcoexist,
2389 BTC_ANT_PATH_BT, false, true);
2390 /* set PTA control */
2391 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2392 btc8821a1ant_coex_table_with_type(btcoexist,
2393 NORMAL_EXEC, 0);
2394 } else if (BTC_IPS_LEAVE == type) {
2395 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2396 "[BTCoex], IPS LEAVE notify\n");
2397 coex_sta->under_ips = false;
2398
2399 btc8821a1ant_init_hw_config(btcoexist, false, false);
2400 btc8821a1ant_init_coex_dm(btcoexist);
2401 btc8821a1ant_query_bt_info(btcoexist);
2402 }
2403 }
2404
ex_btc8821a1ant_lps_notify(struct btc_coexist * btcoexist,u8 type)2405 void ex_btc8821a1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
2406 {
2407 struct rtl_priv *rtlpriv = btcoexist->adapter;
2408
2409 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2410 return;
2411
2412 if (BTC_LPS_ENABLE == type) {
2413 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2414 "[BTCoex], LPS ENABLE notify\n");
2415 coex_sta->under_lps = true;
2416 } else if (BTC_LPS_DISABLE == type) {
2417 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2418 "[BTCoex], LPS DISABLE notify\n");
2419 coex_sta->under_lps = false;
2420 }
2421 }
2422
ex_btc8821a1ant_scan_notify(struct btc_coexist * btcoexist,u8 type)2423 void ex_btc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
2424 {
2425 struct rtl_priv *rtlpriv = btcoexist->adapter;
2426 bool wifi_connected = false, bt_hs_on = false;
2427 bool bt_ctrl_agg_buf_size = false;
2428 bool wifi_under_5g = false;
2429 u32 wifi_link_status = 0;
2430 u32 num_of_wifi_link = 0;
2431 u8 agg_buf_size = 5;
2432
2433 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2434 return;
2435 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2436 if (wifi_under_5g) {
2437 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2438 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2439 btc8821a1ant_coex_under_5g(btcoexist);
2440 return;
2441 }
2442
2443 if (type == BTC_SCAN_START) {
2444 coex_sta->wifi_is_high_pri_task = true;
2445 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2446 "[BTCoex], SCAN START notify\n");
2447
2448 /* Force antenna setup for no scan result issue */
2449 btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2450 } else {
2451 coex_sta->wifi_is_high_pri_task = false;
2452 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2453 "[BTCoex], SCAN FINISH notify\n");
2454 }
2455
2456 if (coex_sta->bt_disabled)
2457 return;
2458
2459 btcoexist->btc_get(btcoexist,
2460 BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2461 btcoexist->btc_get(btcoexist,
2462 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2463
2464 btc8821a1ant_query_bt_info(btcoexist);
2465
2466 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2467 &wifi_link_status);
2468 num_of_wifi_link = wifi_link_status >> 16;
2469 if (num_of_wifi_link >= 2) {
2470 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2471 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2472 bt_ctrl_agg_buf_size, agg_buf_size);
2473 btc8821a1ant_action_wifi_multi_port(btcoexist);
2474 return;
2475 }
2476
2477 if (coex_sta->c2h_bt_inquiry_page) {
2478 btc8821a1ant_action_bt_inquiry(btcoexist);
2479 return;
2480 } else if (bt_hs_on) {
2481 btc8821a1ant_action_hs(btcoexist);
2482 return;
2483 }
2484
2485 if (BTC_SCAN_START == type) {
2486 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2487 "[BTCoex], SCAN START notify\n");
2488 if (!wifi_connected) {
2489 /* non-connected scan */
2490 btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2491 } else {
2492 /* wifi is connected */
2493 btc8821a1ant_action_wifi_connected_scan(btcoexist);
2494 }
2495 } else if (BTC_SCAN_FINISH == type) {
2496 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2497 "[BTCoex], SCAN FINISH notify\n");
2498 if (!wifi_connected) {
2499 /* non-connected scan */
2500 btc8821a1ant_action_wifi_not_connected(btcoexist);
2501 } else {
2502 btc8821a1ant_action_wifi_connected(btcoexist);
2503 }
2504 }
2505 }
2506
ex_btc8821a1ant_connect_notify(struct btc_coexist * btcoexist,u8 type)2507 void ex_btc8821a1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
2508 {
2509 struct rtl_priv *rtlpriv = btcoexist->adapter;
2510 bool wifi_connected = false, bt_hs_on = false;
2511 u32 wifi_link_status = 0;
2512 u32 num_of_wifi_link = 0;
2513 bool bt_ctrl_agg_buf_size = false;
2514 bool wifi_under_5g = false;
2515 u8 agg_buf_size = 5;
2516
2517 if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2518 coex_sta->bt_disabled)
2519 return;
2520 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2521 if (wifi_under_5g) {
2522 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2523 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2524 btc8821a1ant_coex_under_5g(btcoexist);
2525 return;
2526 }
2527
2528 if (type == BTC_ASSOCIATE_START) {
2529 coex_sta->wifi_is_high_pri_task = true;
2530 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2531 "[BTCoex], CONNECT START notify\n");
2532 coex_dm->arp_cnt = 0;
2533 } else {
2534 coex_sta->wifi_is_high_pri_task = false;
2535 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2536 "[BTCoex], CONNECT FINISH notify\n");
2537 coex_dm->arp_cnt = 0;
2538 }
2539
2540 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2541 &wifi_link_status);
2542 num_of_wifi_link = wifi_link_status >> 16;
2543 if (num_of_wifi_link >= 2) {
2544 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2545 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2546 bt_ctrl_agg_buf_size, agg_buf_size);
2547 btc8821a1ant_action_wifi_multi_port(btcoexist);
2548 return;
2549 }
2550
2551 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2552 if (coex_sta->c2h_bt_inquiry_page) {
2553 btc8821a1ant_action_bt_inquiry(btcoexist);
2554 return;
2555 } else if (bt_hs_on) {
2556 btc8821a1ant_action_hs(btcoexist);
2557 return;
2558 }
2559
2560 if (BTC_ASSOCIATE_START == type) {
2561 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2562 "[BTCoex], CONNECT START notify\n");
2563 btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2564 } else if (BTC_ASSOCIATE_FINISH == type) {
2565 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2566 "[BTCoex], CONNECT FINISH notify\n");
2567
2568 btcoexist->btc_get(btcoexist,
2569 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2570 if (!wifi_connected) {
2571 /* non-connected scan */
2572 btc8821a1ant_action_wifi_not_connected(btcoexist);
2573 } else {
2574 btc8821a1ant_action_wifi_connected(btcoexist);
2575 }
2576 }
2577 }
2578
ex_btc8821a1ant_media_status_notify(struct btc_coexist * btcoexist,u8 type)2579 void ex_btc8821a1ant_media_status_notify(struct btc_coexist *btcoexist,
2580 u8 type)
2581 {
2582 struct rtl_priv *rtlpriv = btcoexist->adapter;
2583 u8 h2c_parameter[3] = {0};
2584 u32 wifi_bw;
2585 u8 wifi_central_chnl;
2586 bool wifi_under_5g = false;
2587
2588 if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2589 coex_sta->bt_disabled)
2590 return;
2591 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2592 if (wifi_under_5g) {
2593 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2594 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2595 btc8821a1ant_coex_under_5g(btcoexist);
2596 return;
2597 }
2598
2599 if (BTC_MEDIA_CONNECT == type) {
2600 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2601 "[BTCoex], MEDIA connect notify\n");
2602 } else {
2603 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2604 "[BTCoex], MEDIA disconnect notify\n");
2605 coex_dm->arp_cnt = 0;
2606 }
2607
2608 /* only 2.4G we need to inform bt the chnl mask */
2609 btcoexist->btc_get(btcoexist,
2610 BTC_GET_U1_WIFI_CENTRAL_CHNL,
2611 &wifi_central_chnl);
2612 if ((type == BTC_MEDIA_CONNECT) &&
2613 (wifi_central_chnl <= 14)) {
2614 h2c_parameter[0] = 0x0;
2615 h2c_parameter[1] = wifi_central_chnl;
2616 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2617 if (wifi_bw == BTC_WIFI_BW_HT40)
2618 h2c_parameter[2] = 0x30;
2619 else
2620 h2c_parameter[2] = 0x20;
2621 }
2622
2623 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
2624 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
2625 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
2626
2627 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2628 "[BTCoex], FW write 0x66 = 0x%x\n",
2629 h2c_parameter[0] << 16 |
2630 h2c_parameter[1] << 8 |
2631 h2c_parameter[2]);
2632
2633 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
2634 }
2635
ex_btc8821a1ant_special_packet_notify(struct btc_coexist * btcoexist,u8 type)2636 void ex_btc8821a1ant_special_packet_notify(struct btc_coexist *btcoexist,
2637 u8 type)
2638 {
2639 struct rtl_priv *rtlpriv = btcoexist->adapter;
2640 bool bt_hs_on = false;
2641 bool bt_ctrl_agg_buf_size = false;
2642 bool wifi_under_5g = false;
2643 u32 wifi_link_status = 0;
2644 u32 num_of_wifi_link = 0;
2645 u8 agg_buf_size = 5;
2646
2647 if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2648 coex_sta->bt_disabled)
2649 return;
2650
2651 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2652 if (wifi_under_5g) {
2653 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2654 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2655 btc8821a1ant_coex_under_5g(btcoexist);
2656 return;
2657 }
2658
2659 if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
2660 type == BTC_PACKET_ARP) {
2661 coex_sta->wifi_is_high_pri_task = true;
2662
2663 if (type == BTC_PACKET_ARP) {
2664 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2665 "[BTCoex], specific Packet ARP notify\n");
2666 } else {
2667 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2668 "[BTCoex], specific Packet DHCP or EAPOL notify\n");
2669 }
2670 } else {
2671 coex_sta->wifi_is_high_pri_task = false;
2672 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2673 "[BTCoex], specific Packet [Type = %d] notify\n",
2674 type);
2675 }
2676
2677 coex_sta->special_pkt_period_cnt = 0;
2678
2679 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2680 &wifi_link_status);
2681 num_of_wifi_link = wifi_link_status >> 16;
2682 if (num_of_wifi_link >= 2) {
2683 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2684 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2685 bt_ctrl_agg_buf_size, agg_buf_size);
2686 btc8821a1ant_action_wifi_multi_port(btcoexist);
2687 return;
2688 }
2689
2690 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2691 if (coex_sta->c2h_bt_inquiry_page) {
2692 btc8821a1ant_action_bt_inquiry(btcoexist);
2693 return;
2694 } else if (bt_hs_on) {
2695 btc8821a1ant_action_hs(btcoexist);
2696 return;
2697 }
2698
2699 if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
2700 type == BTC_PACKET_ARP) {
2701 if (type == BTC_PACKET_ARP) {
2702 coex_dm->arp_cnt++;
2703 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2704 "[BTCoex], ARP Packet Count = %d\n",
2705 coex_dm->arp_cnt);
2706 if (coex_dm->arp_cnt >= 10)
2707 /* if APR PKT > 10 after connect, do not go to
2708 * btc8821a1ant_act_wifi_conn_sp_pkt
2709 */
2710 return;
2711 }
2712
2713 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2714 "[BTCoex], special Packet(%d) notify\n", type);
2715 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
2716 }
2717 }
2718
ex_btc8821a1ant_bt_info_notify(struct btc_coexist * btcoexist,u8 * tmp_buf,u8 length)2719 void ex_btc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
2720 u8 *tmp_buf, u8 length)
2721 {
2722 struct rtl_priv *rtlpriv = btcoexist->adapter;
2723 u8 i;
2724 u8 bt_info = 0;
2725 u8 rsp_source = 0;
2726 bool wifi_connected = false;
2727 bool bt_busy = false;
2728 bool wifi_under_5g = false;
2729
2730 coex_sta->c2h_bt_info_req_sent = false;
2731
2732 btcoexist->btc_get(btcoexist,
2733 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2734
2735 rsp_source = tmp_buf[0] & 0xf;
2736 if (rsp_source >= BT_INFO_SRC_8821A_1ANT_MAX)
2737 rsp_source = BT_INFO_SRC_8821A_1ANT_WIFI_FW;
2738 coex_sta->bt_info_c2h_cnt[rsp_source]++;
2739
2740 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2741 "[BTCoex], Bt info[%d], length = %d, hex data = [",
2742 rsp_source, length);
2743 for (i = 0; i < length; i++) {
2744 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
2745 if (i == 1)
2746 bt_info = tmp_buf[i];
2747 if (i == length - 1) {
2748 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2749 "0x%02x]\n", tmp_buf[i]);
2750 } else {
2751 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2752 "0x%02x, ", tmp_buf[i]);
2753 }
2754 }
2755
2756 if (BT_INFO_SRC_8821A_1ANT_WIFI_FW != rsp_source) {
2757 /* [3:0] */
2758 coex_sta->bt_retry_cnt =
2759 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
2760
2761 coex_sta->bt_rssi =
2762 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
2763
2764 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
2765
2766 coex_sta->bt_tx_rx_mask =
2767 (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
2768 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
2769 &coex_sta->bt_tx_rx_mask);
2770 if (!coex_sta->bt_tx_rx_mask) {
2771 /* BT into is responded by BT FW and BT RF REG 0x3C !=
2772 * 0x15 => Need to switch BT TRx Mask
2773 */
2774 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2775 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
2776 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
2777 0x3c, 0x15);
2778 }
2779
2780 /* Here we need to resend some wifi info to BT
2781 * because bt is reset and lost the info
2782 */
2783 if (coex_sta->bt_info_ext & BIT1) {
2784 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2785 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
2786 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2787 &wifi_connected);
2788 if (wifi_connected) {
2789 ex_btc8821a1ant_media_status_notify(btcoexist,
2790 BTC_MEDIA_CONNECT);
2791 } else {
2792 ex_btc8821a1ant_media_status_notify(btcoexist,
2793 BTC_MEDIA_DISCONNECT);
2794 }
2795 }
2796
2797 if ((coex_sta->bt_info_ext & BIT3) && !wifi_under_5g) {
2798 if (!btcoexist->manual_control &&
2799 !btcoexist->stop_coex_dm) {
2800 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2801 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
2802 btc8821a1ant_ignore_wlan_act(btcoexist,
2803 FORCE_EXEC,
2804 false);
2805 }
2806 }
2807 }
2808
2809 /* check BIT2 first ==> check if bt is under inquiry or page scan */
2810 if (bt_info & BT_INFO_8821A_1ANT_B_INQ_PAGE)
2811 coex_sta->c2h_bt_inquiry_page = true;
2812 else
2813 coex_sta->c2h_bt_inquiry_page = false;
2814
2815 /* set link exist status */
2816 if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) {
2817 coex_sta->bt_link_exist = false;
2818 coex_sta->pan_exist = false;
2819 coex_sta->a2dp_exist = false;
2820 coex_sta->hid_exist = false;
2821 coex_sta->sco_exist = false;
2822 } else {
2823 /* connection exists */
2824 coex_sta->bt_link_exist = true;
2825 if (bt_info & BT_INFO_8821A_1ANT_B_FTP)
2826 coex_sta->pan_exist = true;
2827 else
2828 coex_sta->pan_exist = false;
2829 if (bt_info & BT_INFO_8821A_1ANT_B_A2DP)
2830 coex_sta->a2dp_exist = true;
2831 else
2832 coex_sta->a2dp_exist = false;
2833 if (bt_info & BT_INFO_8821A_1ANT_B_HID)
2834 coex_sta->hid_exist = true;
2835 else
2836 coex_sta->hid_exist = false;
2837 if (bt_info & BT_INFO_8821A_1ANT_B_SCO_ESCO)
2838 coex_sta->sco_exist = true;
2839 else
2840 coex_sta->sco_exist = false;
2841 }
2842
2843 btc8821a1ant_update_bt_link_info(btcoexist);
2844
2845 /* mask profile bit for connect-ilde identification
2846 * (for CSR case: A2DP idle --> 0x41)
2847 */
2848 bt_info = bt_info & 0x1f;
2849
2850 if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) {
2851 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
2852 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2853 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
2854 } else if (bt_info == BT_INFO_8821A_1ANT_B_CONNECTION) {
2855 /* connection exists but no busy */
2856 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE;
2857 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2858 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
2859 } else if ((bt_info&BT_INFO_8821A_1ANT_B_SCO_ESCO) ||
2860 (bt_info & BT_INFO_8821A_1ANT_B_SCO_BUSY)) {
2861 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_SCO_BUSY;
2862 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2863 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
2864 } else if (bt_info & BT_INFO_8821A_1ANT_B_ACL_BUSY) {
2865 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
2866 coex_dm->auto_tdma_adjust = false;
2867 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_ACL_BUSY;
2868 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2869 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
2870 } else {
2871 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_MAX;
2872 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2873 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
2874 }
2875
2876 if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
2877 (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
2878 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
2879 bt_busy = true;
2880 else
2881 bt_busy = false;
2882 btcoexist->btc_set(btcoexist,
2883 BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2884
2885 btc8821a1ant_run_coexist_mechanism(btcoexist);
2886 }
2887
ex_btc8821a1ant_halt_notify(struct btc_coexist * btcoexist)2888 void ex_btc8821a1ant_halt_notify(struct btc_coexist *btcoexist)
2889 {
2890 struct rtl_priv *rtlpriv = btcoexist->adapter;
2891 bool wifi_under_5g = false;
2892
2893 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2894 "[BTCoex], Halt notify\n");
2895 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2896 if (wifi_under_5g) {
2897 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2898 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2899 btc8821a1ant_coex_under_5g(btcoexist);
2900 return;
2901 }
2902
2903
2904 btcoexist->stop_coex_dm = true;
2905
2906 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false, true);
2907 btc8821a1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
2908
2909 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2910 btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
2911
2912 ex_btc8821a1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
2913 }
2914
ex_btc8821a1ant_pnp_notify(struct btc_coexist * btcoexist,u8 pnp_state)2915 void ex_btc8821a1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
2916 {
2917 struct rtl_priv *rtlpriv = btcoexist->adapter;
2918 bool wifi_under_5g = false;
2919
2920 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2921 if (wifi_under_5g) {
2922 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2923 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2924 btc8821a1ant_coex_under_5g(btcoexist);
2925 return;
2926 }
2927
2928 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2929 "[BTCoex], Pnp notify\n");
2930
2931 if (BTC_WIFI_PNP_SLEEP == pnp_state) {
2932 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2933 "[BTCoex], Pnp notify to SLEEP\n");
2934 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch
2935 * state after wakeup.
2936 */
2937 coex_sta->under_ips = false;
2938 coex_sta->under_lps = false;
2939 btcoexist->stop_coex_dm = true;
2940 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2941 0x0, 0x0);
2942 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2943 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2944 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false,
2945 true);
2946 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
2947 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2948 "[BTCoex], Pnp notify to WAKE UP\n");
2949 btcoexist->stop_coex_dm = false;
2950 btc8821a1ant_init_hw_config(btcoexist, false, false);
2951 btc8821a1ant_init_coex_dm(btcoexist);
2952 btc8821a1ant_query_bt_info(btcoexist);
2953 }
2954 }
2955
ex_btc8821a1ant_periodical(struct btc_coexist * btcoexist)2956 void ex_btc8821a1ant_periodical(struct btc_coexist *btcoexist)
2957 {
2958 struct rtl_priv *rtlpriv = btcoexist->adapter;
2959 static u8 dis_ver_info_cnt;
2960 u32 fw_ver = 0, bt_patch_ver = 0;
2961 struct btc_board_info *board_info = &btcoexist->board_info;
2962 struct btc_stack_info *stack_info = &btcoexist->stack_info;
2963
2964 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2965 "[BTCoex], ==========================Periodical===========================\n");
2966
2967 if (dis_ver_info_cnt <= 5) {
2968 dis_ver_info_cnt += 1;
2969 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2970 "[BTCoex], ****************************************************************\n");
2971 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2972 "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
2973 board_info->pg_ant_num,
2974 board_info->btdm_ant_num,
2975 board_info->btdm_ant_pos);
2976 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2977 "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
2978 stack_info->profile_notified ? "Yes" : "No",
2979 stack_info->hci_version);
2980 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
2981 &bt_patch_ver);
2982 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2983 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2984 "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
2985 glcoex_ver_date_8821a_1ant,
2986 glcoex_ver_8821a_1ant,
2987 fw_ver, bt_patch_ver,
2988 bt_patch_ver);
2989 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2990 "[BTCoex], ****************************************************************\n");
2991 }
2992
2993 if (!btcoexist->auto_report_1ant) {
2994 btc8821a1ant_query_bt_info(btcoexist);
2995 btc8821a1ant_monitor_bt_ctr(btcoexist);
2996 } else {
2997 coex_sta->special_pkt_period_cnt++;
2998 }
2999 }
3000
