?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / wireless / realtek / rtlwifi / btcoexist / halbtc8821a2ant.c
blobe9e211fda264f32dcac2f934ff495605ae3e14eb
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2012 Realtek Corporation.*/
3
4 /************************************************************
5 * Description:
6 *
7 * This file is for RTL8821A Co-exist mechanism
8 *
9 * History
10 * 2012/08/22 Cosa first check in.
11 * 2012/11/14 Cosa Revise for 8821A 2Ant out sourcing.
12 *
13 ************************************************************/
14
15 /************************************************************
16 * include files
17 ************************************************************/
18 #include "halbt_precomp.h"
19 /************************************************************
20 * Global variables, these are static variables
21 ************************************************************/
22 static struct coex_dm_8821a_2ant glcoex_dm_8821a_2ant;
23 static struct coex_dm_8821a_2ant *coex_dm = &glcoex_dm_8821a_2ant;
24 static struct coex_sta_8821a_2ant glcoex_sta_8821a_2ant;
25 static struct coex_sta_8821a_2ant *coex_sta = &glcoex_sta_8821a_2ant;
26
27 static const char *const glbt_info_src_8821a_2ant[] = {
28 "BT Info[wifi fw]",
29 "BT Info[bt rsp]",
30 "BT Info[bt auto report]",
31 };
32
33 static u32 glcoex_ver_date_8821a_2ant = 20130618;
34 static u32 glcoex_ver_8821a_2ant = 0x5050;
35
36 /************************************************************
37 * local function proto type if needed
38 *
39 * local function start with btc8821a2ant_
40 ************************************************************/
41 static u8 btc8821a2ant_bt_rssi_state(struct btc_coexist *btcoexist,
42 u8 level_num, u8 rssi_thresh,
43 u8 rssi_thresh1)
44 {
45 struct rtl_priv *rtlpriv = btcoexist->adapter;
46 long bt_rssi = 0;
47 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
48
49 bt_rssi = coex_sta->bt_rssi;
50
51 if (level_num == 2) {
52 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
53 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
54 if (bt_rssi >=
55 rssi_thresh + BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT) {
56 bt_rssi_state = BTC_RSSI_STATE_HIGH;
57 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
58 "[BTCoex], BT Rssi state switch to High\n");
59 } else {
60 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
61 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
62 "[BTCoex], BT Rssi state stay at Low\n");
63 }
64 } else {
65 if (bt_rssi < rssi_thresh) {
66 bt_rssi_state = BTC_RSSI_STATE_LOW;
67 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
68 "[BTCoex], BT Rssi state switch to Low\n");
69 } else {
70 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
71 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
72 "[BTCoex], BT Rssi state stay at High\n");
73 }
74 }
75 } else if (level_num == 3) {
76 if (rssi_thresh > rssi_thresh1) {
77 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
78 "[BTCoex], BT Rssi thresh error!!\n");
79 return coex_sta->pre_bt_rssi_state;
80 }
81
82 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
83 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
84 if (bt_rssi >=
85 (rssi_thresh +
86 BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
87 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
88 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
89 "[BTCoex], BT Rssi state switch to Medium\n");
90 } else {
91 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
92 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
93 "[BTCoex], BT Rssi state stay at Low\n");
94 }
95 } else if ((coex_sta->pre_bt_rssi_state ==
96 BTC_RSSI_STATE_MEDIUM) ||
97 (coex_sta->pre_bt_rssi_state ==
98 BTC_RSSI_STATE_STAY_MEDIUM)) {
99 if (bt_rssi >=
100 (rssi_thresh1 +
101 BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
102 bt_rssi_state = BTC_RSSI_STATE_HIGH;
103 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
104 "[BTCoex], BT Rssi state switch to High\n");
105 } else if (bt_rssi < rssi_thresh) {
106 bt_rssi_state = BTC_RSSI_STATE_LOW;
107 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
108 "[BTCoex], BT Rssi state switch to Low\n");
109 } else {
110 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
111 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
112 "[BTCoex], BT Rssi state stay at Medium\n");
113 }
114 } else {
115 if (bt_rssi < rssi_thresh1) {
116 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
117 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
118 "[BTCoex], BT Rssi state switch to Medium\n");
119 } else {
120 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
121 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
122 "[BTCoex], BT Rssi state stay at High\n");
123 }
124 }
125 }
126
127 coex_sta->pre_bt_rssi_state = bt_rssi_state;
128
129 return bt_rssi_state;
130 }
131
132 static u8 btc8821a2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
133 u8 index, u8 level_num,
134 u8 rssi_thresh, u8 rssi_thresh1)
135 {
136 struct rtl_priv *rtlpriv = btcoexist->adapter;
137 long wifi_rssi = 0;
138 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
139
140 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
141
142 if (level_num == 2) {
143 if ((coex_sta->pre_wifi_rssi_state[index] ==
144 BTC_RSSI_STATE_LOW) ||
145 (coex_sta->pre_wifi_rssi_state[index] ==
146 BTC_RSSI_STATE_STAY_LOW)) {
147 if (wifi_rssi >=
148 (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
149 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
150 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
151 "[BTCoex], wifi RSSI state switch to High\n");
152 } else {
153 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
154 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
155 "[BTCoex], wifi RSSI state stay at Low\n");
156 }
157 } else {
158 if (wifi_rssi < rssi_thresh) {
159 wifi_rssi_state = BTC_RSSI_STATE_LOW;
160 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
161 "[BTCoex], wifi RSSI state switch to Low\n");
162 } else {
163 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
164 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
165 "[BTCoex], wifi RSSI state stay at High\n");
166 }
167 }
168 } else if (level_num == 3) {
169 if (rssi_thresh > rssi_thresh1) {
170 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
171 "[BTCoex], wifi RSSI thresh error!!\n");
172 return coex_sta->pre_wifi_rssi_state[index];
173 }
174
175 if ((coex_sta->pre_wifi_rssi_state[index] ==
176 BTC_RSSI_STATE_LOW) ||
177 (coex_sta->pre_wifi_rssi_state[index] ==
178 BTC_RSSI_STATE_STAY_LOW)) {
179 if (wifi_rssi >=
180 (rssi_thresh +
181 BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
182 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
183 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
184 "[BTCoex], wifi RSSI state switch to Medium\n");
185 } else {
186 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
187 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
188 "[BTCoex], wifi RSSI state stay at Low\n");
189 }
190 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
191 BTC_RSSI_STATE_MEDIUM) ||
192 (coex_sta->pre_wifi_rssi_state[index] ==
193 BTC_RSSI_STATE_STAY_MEDIUM)) {
194 if (wifi_rssi >= (rssi_thresh1 +
195 BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
196 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
197 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
198 "[BTCoex], wifi RSSI state switch to High\n");
199 } else if (wifi_rssi < rssi_thresh) {
200 wifi_rssi_state = BTC_RSSI_STATE_LOW;
201 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
202 "[BTCoex], wifi RSSI state switch to Low\n");
203 } else {
204 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
205 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
206 "[BTCoex], wifi RSSI state stay at Medium\n");
207 }
208 } else {
209 if (wifi_rssi < rssi_thresh1) {
210 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
211 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
212 "[BTCoex], wifi RSSI state switch to Medium\n");
213 } else {
214 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
215 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
216 "[BTCoex], wifi RSSI state stay at High\n");
217 }
218 }
219 }
220 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
221
222 return wifi_rssi_state;
223 }
224
225 static
226 void btc8821a2ant_limited_rx(struct btc_coexist *btcoexist, bool force_exec,
227 bool rej_ap_agg_pkt, bool bt_ctrl_agg_buf_size,
228 u8 agg_buf_size)
229 {
230 bool reject_rx_agg = rej_ap_agg_pkt;
231 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
232 u8 rx_agg_size = agg_buf_size;
233
234 /* Rx Aggregation related setting */
235 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
236 &reject_rx_agg);
237 /* decide BT control aggregation buf size or not */
238 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
239 &bt_ctrl_rx_agg_size);
240 /* aggregation buf size, works when BT control Rx aggregation size */
241 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
242 /* real update aggregation setting */
243 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
244 }
245
246 static void btc8821a2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
247 {
248 struct rtl_priv *rtlpriv = btcoexist->adapter;
249 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
250 u32 reg_hp_txrx, reg_lp_txrx, u4tmp;
251 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
252
253 reg_hp_txrx = 0x770;
254 reg_lp_txrx = 0x774;
255
256 u4tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
257 reg_hp_tx = u4tmp & MASKLWORD;
258 reg_hp_rx = (u4tmp & MASKHWORD) >> 16;
259
260 u4tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
261 reg_lp_tx = u4tmp & MASKLWORD;
262 reg_lp_rx = (u4tmp & MASKHWORD) >> 16;
263
264 coex_sta->high_priority_tx = reg_hp_tx;
265 coex_sta->high_priority_rx = reg_hp_rx;
266 coex_sta->low_priority_tx = reg_lp_tx;
267 coex_sta->low_priority_rx = reg_lp_rx;
268
269 if ((coex_sta->low_priority_rx >= 950) &&
270 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
271 (!coex_sta->under_ips))
272 bt_link_info->slave_role = true;
273 else
274 bt_link_info->slave_role = false;
275
276 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
277 "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
278 reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
279 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
280 "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
281 reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
282
283 /* reset counter */
284 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
285 }
286
287 static void btc8821a2ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
288 {
289 if (coex_sta->under_ips) {
290 coex_sta->crc_ok_cck = 0;
291 coex_sta->crc_ok_11g = 0;
292 coex_sta->crc_ok_11n = 0;
293 coex_sta->crc_ok_11n_agg = 0;
294
295 coex_sta->crc_err_cck = 0;
296 coex_sta->crc_err_11g = 0;
297 coex_sta->crc_err_11n = 0;
298 coex_sta->crc_err_11n_agg = 0;
299 } else {
300 coex_sta->crc_ok_cck =
301 btcoexist->btc_read_4byte(btcoexist, 0xf88);
302 coex_sta->crc_ok_11g =
303 btcoexist->btc_read_2byte(btcoexist, 0xf94);
304 coex_sta->crc_ok_11n =
305 btcoexist->btc_read_2byte(btcoexist, 0xf90);
306 coex_sta->crc_ok_11n_agg =
307 btcoexist->btc_read_2byte(btcoexist, 0xfb8);
308
309 coex_sta->crc_err_cck =
310 btcoexist->btc_read_4byte(btcoexist, 0xf84);
311 coex_sta->crc_err_11g =
312 btcoexist->btc_read_2byte(btcoexist, 0xf96);
313 coex_sta->crc_err_11n =
314 btcoexist->btc_read_2byte(btcoexist, 0xf92);
315 coex_sta->crc_err_11n_agg =
316 btcoexist->btc_read_2byte(btcoexist, 0xfba);
317 }
318
319 /* reset counter */
320 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
321 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
322 }
323
324 static void btc8821a2ant_query_bt_info(struct btc_coexist *btcoexist)
325 {
326 struct rtl_priv *rtlpriv = btcoexist->adapter;
327 u8 h2c_parameter[1] = {0};
328
329 coex_sta->c2h_bt_info_req_sent = true;
330
331 h2c_parameter[0] |= BIT0; /* trigger */
332
333 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
334 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
335 h2c_parameter[0]);
336
337 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
338 }
339
340 static bool btc8821a2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
341 {
342 static bool pre_wifi_busy = true;
343 static bool pre_under_4way = true;
344 static bool pre_bt_hs_on = true;
345 bool wifi_busy = false, under_4way = false, bt_hs_on = false;
346 bool wifi_connected = false;
347 u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
348
349 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
350 &wifi_connected);
351 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
352 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
353 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
354 &under_4way);
355
356 if (wifi_connected) {
357 if (wifi_busy != pre_wifi_busy) {
358 pre_wifi_busy = wifi_busy;
359 return true;
360 }
361 if (under_4way != pre_under_4way) {
362 pre_under_4way = under_4way;
363 return true;
364 }
365 if (bt_hs_on != pre_bt_hs_on) {
366 pre_bt_hs_on = bt_hs_on;
367 return true;
368 }
369
370 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 3, 2,
371 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
372
373 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
374 (wifi_rssi_state == BTC_RSSI_STATE_LOW))
375 return true;
376 }
377
378 return false;
379 }
380
381 static void btc8821a2ant_update_bt_link_info(struct btc_coexist *btcoexist)
382 {
383 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
384 bool bt_hs_on = false;
385
386 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
387
388 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
389 bt_link_info->sco_exist = coex_sta->sco_exist;
390 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
391 bt_link_info->pan_exist = coex_sta->pan_exist;
392 bt_link_info->hid_exist = coex_sta->hid_exist;
393
394 /* work around for HS mode. */
395 if (bt_hs_on) {
396 bt_link_info->pan_exist = true;
397 bt_link_info->bt_link_exist = true;
398 }
399
400 /* check if Sco only */
401 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
402 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
403 bt_link_info->sco_only = true;
404 else
405 bt_link_info->sco_only = false;
406
407 /* check if A2dp only */
408 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
409 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
410 bt_link_info->a2dp_only = true;
411 else
412 bt_link_info->a2dp_only = false;
413
414 /* check if Pan only */
415 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
416 bt_link_info->pan_exist && !bt_link_info->hid_exist)
417 bt_link_info->pan_only = true;
418 else
419 bt_link_info->pan_only = false;
420
421 /* check if Hid only */
422 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
423 !bt_link_info->pan_exist && bt_link_info->hid_exist)
424 bt_link_info->hid_only = true;
425 else
426 bt_link_info->hid_only = false;
427 }
428
429 static u8 btc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
430 {
431 struct rtl_priv *rtlpriv = btcoexist->adapter;
432 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
433 bool bt_hs_on = false;
434 u8 algorithm = BT_8821A_2ANT_COEX_ALGO_UNDEFINED;
435 u8 num_of_diff_profile = 0;
436
437 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
438
439 if (!bt_link_info->bt_link_exist) {
440 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
441 "[BTCoex], No BT link exists!!!\n");
442 return algorithm;
443 }
444
445 if (bt_link_info->sco_exist)
446 num_of_diff_profile++;
447 if (bt_link_info->hid_exist)
448 num_of_diff_profile++;
449 if (bt_link_info->pan_exist)
450 num_of_diff_profile++;
451 if (bt_link_info->a2dp_exist)
452 num_of_diff_profile++;
453
454 if (num_of_diff_profile == 1) {
455 if (bt_link_info->sco_exist) {
456 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
457 "[BTCoex], SCO only\n");
458 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
459 } else {
460 if (bt_link_info->hid_exist) {
461 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
462 "[BTCoex], HID only\n");
463 algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
464 } else if (bt_link_info->a2dp_exist) {
465 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
466 "[BTCoex], A2DP only\n");
467 algorithm = BT_8821A_2ANT_COEX_ALGO_A2DP;
468 } else if (bt_link_info->pan_exist) {
469 if (bt_hs_on) {
470 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
471 DBG_LOUD,
472 "[BTCoex], PAN(HS) only\n");
473 algorithm = BT_8821A_2ANT_COEX_ALGO_PANHS;
474 } else {
475 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
476 DBG_LOUD,
477 "[BTCoex], PAN(EDR) only\n");
478 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR;
479 }
480 }
481 }
482 } else if (num_of_diff_profile == 2) {
483 if (bt_link_info->sco_exist) {
484 if (bt_link_info->hid_exist) {
485 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
486 "[BTCoex], SCO + HID\n");
487 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
488 } else if (bt_link_info->a2dp_exist) {
489 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
490 "[BTCoex], SCO + A2DP ==> SCO\n");
491 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
492 } else if (bt_link_info->pan_exist) {
493 if (bt_hs_on) {
494 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
495 DBG_LOUD,
496 "[BTCoex], SCO + PAN(HS)\n");
497 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
498 } else {
499 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
500 DBG_LOUD,
501 "[BTCoex], SCO + PAN(EDR)\n");
502 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
503 }
504 }
505 } else {
506 if (bt_link_info->hid_exist &&
507 bt_link_info->a2dp_exist) {
508 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
509 "[BTCoex], HID + A2DP\n");
510 algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
511 } else if (bt_link_info->hid_exist &&
512 bt_link_info->pan_exist) {
513 if (bt_hs_on) {
514 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
515 DBG_LOUD,
516 "[BTCoex], HID + PAN(HS)\n");
517 algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
518 } else {
519 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
520 DBG_LOUD,
521 "[BTCoex], HID + PAN(EDR)\n");
522 algorithm =
523 BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
524 }
525 } else if (bt_link_info->pan_exist &&
526 bt_link_info->a2dp_exist) {
527 if (bt_hs_on) {
528 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
529 DBG_LOUD,
530 "[BTCoex], A2DP + PAN(HS)\n");
531 algorithm =
532 BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS;
533 } else {
534 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
535 DBG_LOUD,
536 "[BTCoex], A2DP + PAN(EDR)\n");
537 algorithm =
538 BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP;
539 }
540 }
541 }
542 } else if (num_of_diff_profile == 3) {
543 if (bt_link_info->sco_exist) {
544 if (bt_link_info->hid_exist &&
545 bt_link_info->a2dp_exist) {
546 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
547 "[BTCoex], SCO + HID + A2DP ==> HID\n");
548 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
549 } else if (bt_link_info->hid_exist &&
550 bt_link_info->pan_exist) {
551 if (bt_hs_on) {
552 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
553 DBG_LOUD,
554 "[BTCoex], SCO + HID + PAN(HS)\n");
555 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
556 } else {
557 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
558 DBG_LOUD,
559 "[BTCoex], SCO + HID + PAN(EDR)\n");
560 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
561 }
562 } else if (bt_link_info->pan_exist &&
563 bt_link_info->a2dp_exist) {
564 if (bt_hs_on) {
565 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
566 DBG_LOUD,
567 "[BTCoex], SCO + A2DP + PAN(HS)\n");
568 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
569 } else {
570 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
571 DBG_LOUD,
572 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
573 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
574 }
575 }
576 } else {
577 if (bt_link_info->hid_exist &&
578 bt_link_info->pan_exist &&
579 bt_link_info->a2dp_exist) {
580 if (bt_hs_on) {
581 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
582 DBG_LOUD,
583 "[BTCoex], HID + A2DP + PAN(HS)\n");
584 algorithm =
585 BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
586 } else {
587 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
588 DBG_LOUD,
589 "[BTCoex], HID + A2DP + PAN(EDR)\n");
590 algorithm =
591 BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
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->pan_exist &&
599 bt_link_info->a2dp_exist) {
600 if (bt_hs_on) {
601 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
602 DBG_LOUD,
603 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
604
605 } else {
606 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
607 DBG_LOUD,
608 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
609 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
610 }
611 }
612 }
613 }
614 return algorithm;
615 }
616
617 static void btc8821a2ant_set_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
618 u8 dac_swing_lvl)
619 {
620 struct rtl_priv *rtlpriv = btcoexist->adapter;
621 u8 h2c_parameter[1] = {0};
622
623 /* There are several type of dacswing
624 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
625 */
626 h2c_parameter[0] = dac_swing_lvl;
627
628 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
629 "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swing_lvl);
630 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
631 "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
632
633 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
634 }
635
636 static void btc8821a2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
637 u8 dec_bt_pwr_lvl)
638 {
639 struct rtl_priv *rtlpriv = btcoexist->adapter;
640 u8 h2c_parameter[1] = {0};
641
642 h2c_parameter[0] = dec_bt_pwr_lvl;
643
644 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
645 "[BTCoex], decrease Bt Power Level : %u, FW write 0x62 = 0x%x\n",
646 dec_bt_pwr_lvl, h2c_parameter[0]);
647
648 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
649 }
650
651 static void btc8821a2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
652 bool force_exec, u8 dec_bt_pwr_lvl)
653 {
654 struct rtl_priv *rtlpriv = btcoexist->adapter;
655
656 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
657 "[BTCoex], %s Dec BT power level = %u\n",
658 (force_exec ? "force to" : ""), dec_bt_pwr_lvl);
659 coex_dm->cur_dec_bt_pwr_lvl = dec_bt_pwr_lvl;
660
661 if (!force_exec) {
662 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
663 "[BTCoex], pre_dec_bt_pwr_lvl = %d, cur_dec_bt_pwr_lvl = %d\n",
664 coex_dm->pre_dec_bt_pwr_lvl,
665 coex_dm->cur_dec_bt_pwr_lvl);
666
667 if (coex_dm->pre_dec_bt_pwr_lvl == coex_dm->cur_dec_bt_pwr_lvl)
668 return;
669 }
670 btc8821a2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr_lvl);
671
672 coex_dm->pre_dec_bt_pwr_lvl = coex_dm->cur_dec_bt_pwr_lvl;
673 }
674
675 static void btc8821a2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
676 bool force_exec, u8 fw_dac_swing_lvl)
677 {
678 struct rtl_priv *rtlpriv = btcoexist->adapter;
679
680 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
681 "[BTCoex], %s set FW Dac Swing level = %d\n",
682 (force_exec ? "force to" : ""), fw_dac_swing_lvl);
683 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
684
685 if (!force_exec) {
686 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
687 "[BTCoex], pre_fw_dac_swing_lvl = %d, cur_fw_dac_swing_lvl = %d\n",
688 coex_dm->pre_fw_dac_swing_lvl,
689 coex_dm->cur_fw_dac_swing_lvl);
690
691 if (coex_dm->pre_fw_dac_swing_lvl ==
692 coex_dm->cur_fw_dac_swing_lvl)
693 return;
694 }
695
696 btc8821a2ant_set_fw_dac_swing_lvl(btcoexist,
697 coex_dm->cur_fw_dac_swing_lvl);
698
699 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
700 }
701
702 static void btc8821a2ant_set_sw_penalty_tx_rate_adaptive(
703 struct btc_coexist *btcoexist, bool low_penalty_ra)
704 {
705 struct rtl_priv *rtlpriv = btcoexist->adapter;
706 u8 h2c_parameter[6] = {0};
707
708 h2c_parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
709
710 if (low_penalty_ra) {
711 h2c_parameter[1] |= BIT0;
712 /* normal rate except MCS7/6/5, OFDM54/48/36 */
713 h2c_parameter[2] = 0x00;
714 /* MCS7 or OFDM54 */
715 h2c_parameter[3] = 0xf5;
716 /* MCS6 or OFDM48 */
717 h2c_parameter[4] = 0xa0;
718 /* MCS5 or OFDM36 */
719 h2c_parameter[5] = 0xa0;
720 }
721
722 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
723 "[BTCoex], set WiFi Low-Penalty Retry: %s",
724 (low_penalty_ra ? "ON!!" : "OFF!!"));
725
726 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
727 }
728
729 static void btc8821a2ant_low_penalty_ra(struct btc_coexist *btcoexist,
730 bool force_exec, bool low_penalty_ra)
731 {
732 struct rtl_priv *rtlpriv = btcoexist->adapter;
733
734 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
735 "[BTCoex], %s turn LowPenaltyRA = %s\n",
736 (force_exec ? "force to" : ""),
737 ((low_penalty_ra) ? "ON" : "OFF"));
738 coex_dm->cur_low_penalty_ra = low_penalty_ra;
739
740 if (!force_exec) {
741 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
742 "[BTCoex], pre_low_penalty_ra = %d, cur_low_penalty_ra = %d\n",
743 coex_dm->pre_low_penalty_ra,
744 coex_dm->cur_low_penalty_ra);
745
746 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
747 return;
748 }
749 btc8821a2ant_set_sw_penalty_tx_rate_adaptive(btcoexist,
750 coex_dm->cur_low_penalty_ra);
751
752 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
753 }
754
755 static void btc8821a2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
756 u32 level)
757 {
758 struct rtl_priv *rtlpriv = btcoexist->adapter;
759 u8 val = (u8)level;
760
761 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
762 "[BTCoex], Write SwDacSwing = 0x%x\n", level);
763 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc5b, 0x3e, val);
764 }
765
766 static void btc8821a2ant_set_sw_full_dac_swing(struct btc_coexist *btcoexist,
767 bool sw_dac_swing_on,
768 u32 sw_dac_swing_lvl)
769 {
770 if (sw_dac_swing_on)
771 btc8821a2ant_set_dac_swing_reg(btcoexist, sw_dac_swing_lvl);
772 else
773 btc8821a2ant_set_dac_swing_reg(btcoexist, 0x18);
774 }
775
776 static void btc8821a2ant_dac_swing(struct btc_coexist *btcoexist,
777 bool force_exec, bool dac_swing_on,
778 u32 dac_swing_lvl)
779 {
780 struct rtl_priv *rtlpriv = btcoexist->adapter;
781
782 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
783 "[BTCoex], %s turn DacSwing = %s, dac_swing_lvl = 0x%x\n",
784 (force_exec ? "force to" : ""),
785 ((dac_swing_on) ? "ON" : "OFF"),
786 dac_swing_lvl);
787 coex_dm->cur_dac_swing_on = dac_swing_on;
788 coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
789
790 if (!force_exec) {
791 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
792 "[BTCoex], pre_dac_swing_on = %d, pre_dac_swing_lvl = 0x%x, cur_dac_swing_on = %d, cur_dac_swing_lvl = 0x%x\n",
793 coex_dm->pre_dac_swing_on,
794 coex_dm->pre_dac_swing_lvl,
795 coex_dm->cur_dac_swing_on,
796 coex_dm->cur_dac_swing_lvl);
797
798 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
799 (coex_dm->pre_dac_swing_lvl ==
800 coex_dm->cur_dac_swing_lvl))
801 return;
802 }
803 mdelay(30);
804 btc8821a2ant_set_sw_full_dac_swing(btcoexist, dac_swing_on,
805 dac_swing_lvl);
806
807 coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
808 coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
809 }
810
811 static void btc8821a2ant_set_coex_table(struct btc_coexist *btcoexist,
812 u32 val0x6c0, u32 val0x6c4,
813 u32 val0x6c8, u8 val0x6cc)
814 {
815 struct rtl_priv *rtlpriv = btcoexist->adapter;
816
817 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
818 "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
819 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
820
821 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
822 "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
823 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
824
825 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
826 "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
827 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
828
829 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
830 "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
831 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
832 }
833
834 static void btc8821a2ant_coex_table(struct btc_coexist *btcoexist,
835 bool force_exec, u32 val0x6c0,
836 u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
837 {
838 struct rtl_priv *rtlpriv = btcoexist->adapter;
839
840 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
841 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
842 (force_exec ? "force to" : ""),
843 val0x6c0, val0x6c4, val0x6c8, val0x6cc);
844 coex_dm->cur_val0x6c0 = val0x6c0;
845 coex_dm->cur_val0x6c4 = val0x6c4;
846 coex_dm->cur_val0x6c8 = val0x6c8;
847 coex_dm->cur_val0x6cc = val0x6cc;
848
849 if (!force_exec) {
850 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
851 "[BTCoex], pre_val0x6c0 = 0x%x, pre_val0x6c4 = 0x%x, pre_val0x6c8 = 0x%x, pre_val0x6cc = 0x%x !!\n",
852 coex_dm->pre_val0x6c0,
853 coex_dm->pre_val0x6c4,
854 coex_dm->pre_val0x6c8,
855 coex_dm->pre_val0x6cc);
856 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
857 "[BTCoex], cur_val0x6c0 = 0x%x, cur_val0x6c4 = 0x%x, cur_val0x6c8 = 0x%x, cur_val0x6cc = 0x%x !!\n",
858 coex_dm->cur_val0x6c0,
859 coex_dm->cur_val0x6c4,
860 coex_dm->cur_val0x6c8,
861 coex_dm->cur_val0x6cc);
862
863 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
864 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
865 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
866 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
867 return;
868 }
869 btc8821a2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
870 val0x6cc);
871
872 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
873 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
874 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
875 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
876 }
877
878 static void btc8821a2ant_coex_table_with_type(struct btc_coexist *btcoexist,
879 bool force_exec, u8 type)
880 {
881 coex_sta->coex_table_type = type;
882
883 switch (type) {
884 case 0:
885 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55555555,
886 0x55555555, 0xffffff, 0x3);
887 break;
888 case 1:
889 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55555555,
890 0x5afa5afa, 0xffffff, 0x3);
891 break;
892 case 2:
893 btc8821a2ant_coex_table(btcoexist, force_exec, 0x5ada5ada,
894 0x5ada5ada, 0xffffff, 0x3);
895 break;
896 case 3:
897 btc8821a2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
898 0xaaaaaaaa, 0xffffff, 0x3);
899 break;
900 case 4:
901 btc8821a2ant_coex_table(btcoexist, force_exec, 0xffffffff,
902 0xffffffff, 0xffffff, 0x3);
903 break;
904 case 5:
905 btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
906 0x5fff5fff, 0xffffff, 0x3);
907 break;
908 case 6:
909 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
910 0x5a5a5a5a, 0xffffff, 0x3);
911 break;
912 case 7:
913 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
914 0x5ada5ada, 0xffffff, 0x3);
915 break;
916 case 8:
917 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
918 0x5ada5ada, 0xffffff, 0x3);
919 break;
920 case 9:
921 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
922 0x5ada5ada, 0xffffff, 0x3);
923 break;
924 case 10:
925 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
926 0x5ada5ada, 0xffffff, 0x3);
927 break;
928 case 11:
929 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
930 0x5ada5ada, 0xffffff, 0x3);
931 break;
932 case 12:
933 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
934 0x5ada5ada, 0xffffff, 0x3);
935 break;
936 case 13:
937 btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
938 0xaaaaaaaa, 0xffffff, 0x3);
939 break;
940 case 14:
941 btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
942 0x5ada5ada, 0xffffff, 0x3);
943 break;
944 case 15:
945 btc8821a2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
946 0xaaaaaaaa, 0xffffff, 0x3);
947 break;
948 case 16:
949 btc8821a2ant_coex_table(btcoexist, force_exec, 0x5fdf5fdf,
950 0x5fdb5fdb, 0xffffff, 0x3);
951 break;
952 case 17:
953 btc8821a2ant_coex_table(btcoexist, force_exec, 0xfafafafa,
954 0xfafafafa, 0xffffff, 0x3);
955 break;
956 default:
957 break;
958 }
959 }
960
961 static void btc8821a2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoex,
962 bool enable)
963 {
964 struct rtl_priv *rtlpriv = btcoex->adapter;
965 u8 h2c_parameter[1] = {0};
966
967 if (enable)
968 h2c_parameter[0] |= BIT0; /* function enable */
969
970 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
971 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
972 h2c_parameter[0]);
973
974 btcoex->btc_fill_h2c(btcoex, 0x63, 1, h2c_parameter);
975 }
976
977 static void btc8821a2ant_set_lps_rpwm(struct btc_coexist *btcoexist, u8 lps_val,
978 u8 rpwm_val)
979 {
980 u8 lps = lps_val;
981 u8 rpwm = rpwm_val;
982
983 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
984 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
985 }
986
987 static void btc8821a2ant_lps_rpwm(struct btc_coexist *btcoexist,
988 bool force_exec, u8 lps_val, u8 rpwm_val)
989 {
990 coex_dm->cur_lps = lps_val;
991 coex_dm->cur_rpwm = rpwm_val;
992
993 if (!force_exec) {
994 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
995 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
996 return;
997 }
998 btc8821a2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
999
1000 coex_dm->pre_lps = coex_dm->cur_lps;
1001 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1002 }
1003
1004 static void btc8821a2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1005 bool force_exec, bool enable)
1006 {
1007 struct rtl_priv *rtlpriv = btcoexist->adapter;
1008
1009 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1010 "[BTCoex], %s turn Ignore WlanAct %s\n",
1011 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1012 coex_dm->cur_ignore_wlan_act = enable;
1013
1014 if (!force_exec) {
1015 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1016 "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
1017 coex_dm->pre_ignore_wlan_act,
1018 coex_dm->cur_ignore_wlan_act);
1019
1020 if (coex_dm->pre_ignore_wlan_act ==
1021 coex_dm->cur_ignore_wlan_act)
1022 return;
1023 }
1024 btc8821a2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1025
1026 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1027 }
1028
1029 static void btc8821a2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist,
1030 u8 byte1, u8 byte2, u8 byte3,
1031 u8 byte4, u8 byte5)
1032 {
1033 struct rtl_priv *rtlpriv = btcoexist->adapter;
1034 u8 h2c_parameter[5];
1035
1036 h2c_parameter[0] = byte1;
1037 h2c_parameter[1] = byte2;
1038 h2c_parameter[2] = byte3;
1039 h2c_parameter[3] = byte4;
1040 h2c_parameter[4] = byte5;
1041
1042 coex_dm->ps_tdma_para[0] = byte1;
1043 coex_dm->ps_tdma_para[1] = byte2;
1044 coex_dm->ps_tdma_para[2] = byte3;
1045 coex_dm->ps_tdma_para[3] = byte4;
1046 coex_dm->ps_tdma_para[4] = byte5;
1047
1048 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1049 "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
1050 h2c_parameter[0],
1051 h2c_parameter[1] << 24 |
1052 h2c_parameter[2] << 16 |
1053 h2c_parameter[3] << 8 |
1054 h2c_parameter[4]);
1055
1056 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1057 }
1058
1059 static void btc8821a2ant_sw_mechanism1(struct btc_coexist *btcoexist,
1060 bool shrink_rx_lpf, bool low_penalty_ra,
1061 bool limited_dig, bool bt_lna_constrain)
1062 {
1063 btc8821a2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1064 }
1065
1066 static void btc8821a2ant_sw_mechanism2(struct btc_coexist *btcoexist,
1067 bool agc_table_shift, bool adc_back_off,
1068 bool sw_dac_swing, u32 dac_swing_lvl)
1069 {
1070 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1071 dac_swing_lvl);
1072 }
1073
1074 static void btc8821a2ant_set_ant_path(struct btc_coexist *btcoexist,
1075 u8 ant_pos_type, bool init_hw_cfg,
1076 bool wifi_off)
1077 {
1078 struct btc_board_info *board_info = &btcoexist->board_info;
1079 u32 u4tmp = 0;
1080 u8 h2c_parameter[2] = {0};
1081
1082 if (init_hw_cfg) {
1083 /* 0x4c[23] = 0, 0x4c[24] = 1 Antenna control by WL/BT */
1084 u4tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1085 u4tmp &= ~BIT23;
1086 u4tmp |= BIT24;
1087 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4tmp);
1088
1089 btcoexist->btc_write_4byte(btcoexist, 0x974, 0x3ff);
1090
1091 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1092 /* tell firmware "antenna inverse" ==> WRONG firmware
1093 * antenna control code ==>need fw to fix
1094 */
1095 h2c_parameter[0] = 1;
1096 h2c_parameter[1] = 1;
1097 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1098 h2c_parameter);
1099 } else {
1100 /* tell firmware "no antenna inverse" ==> WRONG firmware
1101 * antenna control code ==>need fw to fix
1102 */
1103 h2c_parameter[0] = 0;
1104 h2c_parameter[1] = 1;
1105 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1106 h2c_parameter);
1107 }
1108 }
1109
1110 /* ext switch setting */
1111 switch (ant_pos_type) {
1112 case BTC_ANT_WIFI_AT_MAIN:
1113 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x1);
1114 break;
1115 case BTC_ANT_WIFI_AT_AUX:
1116 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x2);
1117 break;
1118 }
1119 }
1120
1121 static void btc8821a2ant_ps_tdma(struct btc_coexist *btcoexist,
1122 bool force_exec, bool turn_on, u8 type)
1123 {
1124 struct rtl_priv *rtlpriv = btcoexist->adapter;
1125
1126 u8 wifi_rssi_state, bt_rssi_state;
1127
1128 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1129 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
1130 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist, 2,
1131 BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1132
1133 if (!(BTC_RSSI_HIGH(wifi_rssi_state) &&
1134 BTC_RSSI_HIGH(bt_rssi_state)) &&
1135 turn_on) {
1136 /* for WiFi RSSI low or BT RSSI low */
1137 type = type + 100;
1138 }
1139
1140 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1141 "[BTCoex], %s turn %s PS TDMA, type = %d\n",
1142 (force_exec ? "force to" : ""), (turn_on ? "ON" : "OFF"),
1143 type);
1144 coex_dm->cur_ps_tdma_on = turn_on;
1145 coex_dm->cur_ps_tdma = type;
1146
1147 if (!force_exec) {
1148 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1149 "[BTCoex], pre_ps_tdma_on = %d, cur_ps_tdma_on = %d!!\n",
1150 coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1151 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1152 "[BTCoex], pre_ps_tdma = %d, cur_ps_tdma = %d!!\n",
1153 coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1154
1155 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1156 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1157 return;
1158 }
1159 if (turn_on) {
1160 switch (type) {
1161 case 1:
1162 default:
1163 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1164 0x03, 0xf1, 0x90);
1165 break;
1166 case 2:
1167 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1168 0x03, 0xf1, 0x90);
1169 break;
1170 case 3:
1171 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1172 0x3, 0xf1, 0x90);
1173 break;
1174 case 4:
1175 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1176 0x03, 0xf1, 0x90);
1177 break;
1178 case 5:
1179 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1180 0x3, 0x70, 0x90);
1181 break;
1182 case 6:
1183 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1184 0x3, 0x70, 0x90);
1185 break;
1186 case 7:
1187 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1188 0x3, 0x70, 0x90);
1189 break;
1190 case 8:
1191 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1192 0x3, 0x70, 0x90);
1193 break;
1194 case 9:
1195 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1196 0x03, 0xf1, 0x90);
1197 break;
1198 case 10:
1199 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1200 0x03, 0xf1, 0x90);
1201 break;
1202 case 11:
1203 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1204 0x3, 0xf1, 0x90);
1205 break;
1206 case 12:
1207 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1208 0x3, 0xf1, 0x90);
1209 break;
1210 case 13:
1211 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1212 0x3, 0x70, 0x90);
1213 break;
1214 case 14:
1215 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x2d,
1216 0x3, 0x70, 0x90);
1217 break;
1218 case 15:
1219 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1220 0x3, 0x70, 0x90);
1221 break;
1222 case 16:
1223 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1224 0x3, 0x70, 0x90);
1225 break;
1226 case 17:
1227 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1228 0x2f, 0x60, 0x90);
1229 break;
1230 case 18:
1231 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 0x5,
1232 0xe1, 0x90);
1233 break;
1234 case 19:
1235 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1236 0x25, 0xe1, 0x90);
1237 break;
1238 case 20:
1239 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1240 0x25, 0x60, 0x90);
1241 break;
1242 case 21:
1243 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1244 0x03, 0x70, 0x90);
1245 break;
1246 case 23:
1247 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1e,
1248 0x03, 0xf0, 0x14);
1249 break;
1250 case 24:
1251 case 124:
1252 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x3c,
1253 0x03, 0x70, 0x50);
1254 break;
1255 case 25:
1256 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x14,
1257 0x03, 0xf1, 0x90);
1258 break;
1259 case 26:
1260 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x30,
1261 0x03, 0xf1, 0x90);
1262 break;
1263 case 71:
1264 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1265 0x03, 0xf1, 0x90);
1266 break;
1267 case 101:
1268 case 105:
1269 case 171:
1270 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x3a,
1271 0x03, 0x70, 0x50);
1272 break;
1273 case 102:
1274 case 106:
1275 case 110:
1276 case 114:
1277 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x2d,
1278 0x03, 0x70, 0x50);
1279 break;
1280 case 103:
1281 case 107:
1282 case 111:
1283 case 115:
1284 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1285 0x03, 0x70, 0x50);
1286 break;
1287 case 104:
1288 case 108:
1289 case 112:
1290 case 116:
1291 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x10,
1292 0x03, 0x70, 0x50);
1293 break;
1294 case 109:
1295 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1296 0x03, 0xf1, 0x90);
1297 break;
1298 case 113:
1299 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1300 0x03, 0x70, 0x90);
1301 break;
1302 case 121:
1303 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1304 0x03, 0x70, 0x90);
1305 break;
1306 case 22:
1307 case 122:
1308 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1309 0x03, 0x71, 0x11);
1310 break;
1311 case 123:
1312 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1313 0x03, 0x70, 0x54);
1314 break;
1315 case 125:
1316 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x14,
1317 0x03, 0x70, 0x50);
1318 break;
1319 case 126:
1320 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x30,
1321 0x03, 0x70, 0x50);
1322 break;
1323 }
1324 } else {
1325 /* disable PS tdma */
1326 switch (type) {
1327 case 0:
1328 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1329 0x40, 0x0);
1330 break;
1331 case 1:
1332 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1333 0x48, 0x0);
1334 break;
1335 default:
1336 btc8821a2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1337 0x40, 0x0);
1338 break;
1339 }
1340 }
1341
1342 /* update pre state */
1343 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1344 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1345 }
1346
1347 static void
1348 btc8821a2ant_ps_tdma_check_for_power_save_state(struct btc_coexist *btcoexist,
1349 bool new_ps_state)
1350 {
1351 u8 lps_mode = 0x0;
1352
1353 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1354
1355 if (lps_mode) {
1356 /* already under LPS state */
1357 if (new_ps_state) {
1358 /* keep state under LPS, do nothing */
1359 } else {
1360 /* will leave LPS state, turn off psTdma first */
1361 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1362 }
1363 } else {
1364 /* NO PS state */
1365 if (new_ps_state) {
1366 /* will enter LPS state, turn off psTdma first */
1367 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1368 } else {
1369 /* keep state under NO PS state, do nothing */
1370 }
1371 }
1372 }
1373
1374 static void btc8821a2ant_power_save_state(struct btc_coexist *btcoexist,
1375 u8 ps_type, u8 lps_val, u8 rpwm_val)
1376 {
1377 bool low_pwr_disable = false;
1378
1379 switch (ps_type) {
1380 case BTC_PS_WIFI_NATIVE:
1381 /* recover to original 32k low power setting */
1382 low_pwr_disable = false;
1383 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1384 &low_pwr_disable);
1385 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1386 coex_sta->force_lps_on = false;
1387 break;
1388 case BTC_PS_LPS_ON:
1389 btc8821a2ant_ps_tdma_check_for_power_save_state(btcoexist,
1390 true);
1391 btc8821a2ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1392 rpwm_val);
1393 /* when coex force to enter LPS, do not enter 32k low power */
1394 low_pwr_disable = true;
1395 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1396 &low_pwr_disable);
1397 /* power save must executed before psTdma */
1398 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1399 coex_sta->force_lps_on = true;
1400 break;
1401 case BTC_PS_LPS_OFF:
1402 btc8821a2ant_ps_tdma_check_for_power_save_state(btcoexist,
1403 false);
1404 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1405 coex_sta->force_lps_on = false;
1406 break;
1407 default:
1408 break;
1409 }
1410 }
1411
1412 static void btc8821a2ant_coex_all_off(struct btc_coexist *btcoexist)
1413 {
1414 /* fw all off */
1415 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1416 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1417 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1418 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1419
1420 /* sw all off */
1421 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1422 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1423
1424 /* hw all off */
1425 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1426 }
1427
1428 static void btc8821a2ant_coex_under_5g(struct btc_coexist *btcoexist)
1429 {
1430 btc8821a2ant_coex_all_off(btcoexist);
1431 btc8821a2ant_ignore_wlan_act(btcoexist, NORMAL_EXEC, true);
1432 }
1433
1434 static void btc8821a2ant_init_coex_dm(struct btc_coexist *btcoexist)
1435 {
1436 /* force to reset coex mechanism */
1437 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1438
1439 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1440 btc8821a2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1441 btc8821a2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1442 btc8821a2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 0);
1443
1444 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1445 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1446 }
1447
1448 static void btc8821a2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1449 {
1450 struct rtl_priv *rtlpriv = btcoexist->adapter;
1451 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1452 bool wifi_connected = false;
1453 bool low_pwr_disable = true;
1454 bool scan = false, link = false, roam = false;
1455
1456 wifi_rssi_state =
1457 btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1458 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1459 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
1460 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
1461 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1462
1463 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1464 &low_pwr_disable);
1465 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1466 &wifi_connected);
1467
1468 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1469 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1470 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1471
1472 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1473
1474 if (scan || link || roam) {
1475 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1476 "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1477 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1478 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1479 } else if (wifi_connected) {
1480 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1481 "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1482 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1483 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1484 } else {
1485 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1486 "[BTCoex], Wifi no-link + BT Inq/Page!!\n");
1487 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1488 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1489 }
1490
1491 btc8821a2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1492 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1493
1494 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1495 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1496 }
1497
1498 static void btc8821a2ant_action_wifi_link_process(struct btc_coexist *btcoexist)
1499 {
1500 struct rtl_priv *rtlpriv = btcoexist->adapter;
1501 u8 u8tmpa, u8tmpb;
1502
1503 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1504 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1505
1506 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1507 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1508
1509 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1510 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1511
1512 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1513 "[BTCoex], 0x765=0x%x, 0x76e=0x%x\n", u8tmpa, u8tmpb);
1514 }
1515
1516 static bool btc8821a2ant_action_wifi_idle_process(struct btc_coexist *btcoexist)
1517 {
1518 struct rtl_priv *rtlpriv = btcoexist->adapter;
1519 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1520 u8 ap_num = 0;
1521
1522 wifi_rssi_state =
1523 btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1524 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1525 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES - 20, 0);
1526 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
1527 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1528
1529 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1530
1531 /* define the office environment */
1532 if (BTC_RSSI_HIGH(wifi_rssi_state1) && (coex_sta->hid_exist) &&
1533 (coex_sta->a2dp_exist)) {
1534 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1535 "[BTCoex], Wifi idle process for BT HID+A2DP exist!!\n");
1536
1537 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1538 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1539
1540 /* sw all off */
1541 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1542 false);
1543 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1544 0x18);
1545
1546 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1547 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1548 0x0, 0x0);
1549 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1550
1551 return true;
1552 } else if (coex_sta->pan_exist) {
1553 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1554 "[BTCoex], Wifi idle process for BT PAN exist!!\n");
1555
1556 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1557 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1558
1559 /* sw all off */
1560 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1561 false);
1562 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1563 0x18);
1564
1565 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1566 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1567 0x0, 0x0);
1568 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1569
1570 return true;
1571 }
1572 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1573 return false;
1574 }
1575
1576 static bool btc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
1577 {
1578 struct rtl_priv *rtlpriv = btcoexist->adapter;
1579 bool common = false, wifi_connected = false, wifi_busy = false;
1580 bool low_pwr_disable = false;
1581 bool bt_hs_on = false;
1582
1583 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1584 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1585 &wifi_connected);
1586 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1587
1588 if (!wifi_connected) {
1589 low_pwr_disable = false;
1590 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1591 &low_pwr_disable);
1592 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
1593 0x8);
1594
1595 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1596 "[BTCoex], Wifi non-connected idle!!\n");
1597
1598 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1599 0x0);
1600 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1601 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1602 0x0, 0x0);
1603 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1604 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1605 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1606
1607 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1608 false);
1609 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1610 0x18);
1611
1612 common = true;
1613 } else {
1614 if (BT_8821A_2ANT_BT_STATUS_IDLE ==
1615 coex_dm->bt_status) {
1616 low_pwr_disable = false;
1617 btcoexist->btc_set(btcoexist,
1618 BTC_SET_ACT_DISABLE_LOW_POWER,
1619 &low_pwr_disable);
1620 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC,
1621 false, false, 0x8);
1622
1623 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1624 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1625
1626 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1627 0xfffff, 0x0);
1628 btc8821a2ant_coex_table_with_type(btcoexist,
1629 NORMAL_EXEC, 0);
1630
1631 btc8821a2ant_power_save_state(
1632 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1633 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1634 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1635 0xb);
1636 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1637
1638 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
1639 false, false);
1640 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
1641 false, 0x18);
1642
1643 common = true;
1644 } else if (BT_8821A_2ANT_BT_STATUS_CON_IDLE ==
1645 coex_dm->bt_status) {
1646 low_pwr_disable = true;
1647 btcoexist->btc_set(btcoexist,
1648 BTC_SET_ACT_DISABLE_LOW_POWER,
1649 &low_pwr_disable);
1650
1651 if (bt_hs_on)
1652 return false;
1653 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1654 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1655 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC,
1656 false, false, 0x8);
1657
1658 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1659 0xfffff, 0x0);
1660 btc8821a2ant_coex_table_with_type(btcoexist,
1661 NORMAL_EXEC, 0);
1662
1663 btc8821a2ant_power_save_state(
1664 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1665 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1666 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1667 0xb);
1668 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1669
1670 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
1671 false, false);
1672 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
1673 false, 0x18);
1674 common = true;
1675 } else {
1676 low_pwr_disable = true;
1677 btcoexist->btc_set(btcoexist,
1678 BTC_SET_ACT_DISABLE_LOW_POWER,
1679 &low_pwr_disable);
1680
1681 if (wifi_busy) {
1682 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1683 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1684 common = false;
1685 } else {
1686 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1687 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1688 common =
1689 btc8821a2ant_action_wifi_idle_process(
1690 btcoexist);
1691 }
1692 }
1693 }
1694 return common;
1695 }
1696
1697 static void btc8821a2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
1698 bool sco_hid, bool tx_pause,
1699 u8 max_interval)
1700 {
1701 struct rtl_priv *rtlpriv = btcoexist->adapter;
1702 static long up, dn, m, n, wait_count;
1703 /* 0 : no change
1704 * +1: increase WiFi duration
1705 * -1: decrease WiFi duration
1706 */
1707 int result;
1708 u8 retry_count = 0;
1709
1710 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1711 "[BTCoex], TdmaDurationAdjust()\n");
1712
1713 if (coex_dm->auto_tdma_adjust) {
1714 coex_dm->auto_tdma_adjust = false;
1715 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1716 "[BTCoex], first run TdmaDurationAdjust()!!\n");
1717 if (sco_hid) {
1718 if (tx_pause) {
1719 if (max_interval == 1) {
1720 btc8821a2ant_ps_tdma(btcoexist,
1721 NORMAL_EXEC, true, 13);
1722 coex_dm->ps_tdma_du_adj_type = 13;
1723 } else if (max_interval == 2) {
1724 btc8821a2ant_ps_tdma(btcoexist,
1725 NORMAL_EXEC, true, 14);
1726 coex_dm->ps_tdma_du_adj_type = 14;
1727 } else if (max_interval == 3) {
1728 btc8821a2ant_ps_tdma(btcoexist,
1729 NORMAL_EXEC, true, 15);
1730 coex_dm->ps_tdma_du_adj_type = 15;
1731 } else {
1732 btc8821a2ant_ps_tdma(btcoexist,
1733 NORMAL_EXEC, true, 15);
1734 coex_dm->ps_tdma_du_adj_type = 15;
1735 }
1736 } else {
1737 if (max_interval == 1) {
1738 btc8821a2ant_ps_tdma(btcoexist,
1739 NORMAL_EXEC, true, 9);
1740 coex_dm->ps_tdma_du_adj_type = 9;
1741 } else if (max_interval == 2) {
1742 btc8821a2ant_ps_tdma(btcoexist,
1743 NORMAL_EXEC, true, 10);
1744 coex_dm->ps_tdma_du_adj_type = 10;
1745 } else if (max_interval == 3) {
1746 btc8821a2ant_ps_tdma(btcoexist,
1747 NORMAL_EXEC, true, 11);
1748 coex_dm->ps_tdma_du_adj_type = 11;
1749 } else {
1750 btc8821a2ant_ps_tdma(btcoexist,
1751 NORMAL_EXEC, true, 11);
1752 coex_dm->ps_tdma_du_adj_type = 11;
1753 }
1754 }
1755 } else {
1756 if (tx_pause) {
1757 if (max_interval == 1) {
1758 btc8821a2ant_ps_tdma(btcoexist,
1759 NORMAL_EXEC, true, 5);
1760 coex_dm->ps_tdma_du_adj_type = 5;
1761 } else if (max_interval == 2) {
1762 btc8821a2ant_ps_tdma(btcoexist,
1763 NORMAL_EXEC, true, 6);
1764 coex_dm->ps_tdma_du_adj_type = 6;
1765 } else if (max_interval == 3) {
1766 btc8821a2ant_ps_tdma(btcoexist,
1767 NORMAL_EXEC, true, 7);
1768 coex_dm->ps_tdma_du_adj_type = 7;
1769 } else {
1770 btc8821a2ant_ps_tdma(btcoexist,
1771 NORMAL_EXEC, true, 7);
1772 coex_dm->ps_tdma_du_adj_type = 7;
1773 }
1774 } else {
1775 if (max_interval == 1) {
1776 btc8821a2ant_ps_tdma(btcoexist,
1777 NORMAL_EXEC, true, 1);
1778 coex_dm->ps_tdma_du_adj_type = 1;
1779 } else if (max_interval == 2) {
1780 btc8821a2ant_ps_tdma(btcoexist,
1781 NORMAL_EXEC, true, 2);
1782 coex_dm->ps_tdma_du_adj_type = 2;
1783 } else if (max_interval == 3) {
1784 btc8821a2ant_ps_tdma(btcoexist,
1785 NORMAL_EXEC, true, 3);
1786 coex_dm->ps_tdma_du_adj_type = 3;
1787 } else {
1788 btc8821a2ant_ps_tdma(btcoexist,
1789 NORMAL_EXEC, true, 3);
1790 coex_dm->ps_tdma_du_adj_type = 3;
1791 }
1792 }
1793 }
1794
1795 up = 0;
1796 dn = 0;
1797 m = 1;
1798 n = 3;
1799 result = 0;
1800 wait_count = 0;
1801 } else {
1802 /* accquire the BT TRx retry count from BT_Info byte2 */
1803 retry_count = coex_sta->bt_retry_cnt;
1804 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1805 "[BTCoex], retry_count = %d\n", retry_count);
1806 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1807 "[BTCoex], up = %d, dn = %d, m = %d, n = %d, wait_count = %d\n",
1808 (int)up, (int)dn, (int)m, (int)n, (int)wait_count);
1809 result = 0;
1810 wait_count++;
1811
1812 if (retry_count == 0) {
1813 /* no retry in the last 2-second duration */
1814 up++;
1815 dn--;
1816
1817 if (dn <= 0)
1818 dn = 0;
1819
1820 if (up >= n) {
1821 /* if (retry count == 0) for 2*n seconds,
1822 * make WiFi duration wider
1823 */
1824 wait_count = 0;
1825 n = 3;
1826 up = 0;
1827 dn = 0;
1828 result = 1;
1829 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1830 "[BTCoex], Increase wifi duration!!\n");
1831 }
1832 } else if (retry_count <= 3) {
1833 /* <=3 retry in the last 2-second duration */
1834 up--;
1835 dn++;
1836
1837 if (up <= 0)
1838 up = 0;
1839
1840 if (dn == 2) {
1841 /* if retry count < 3 for 2*2 seconds,
1842 * shrink wifi duration
1843 */
1844 if (wait_count <= 2)
1845 m++; /* avoid bounce in two levels */
1846 else
1847 m = 1;
1848 /* m max value is 20, max time is 120 second,
1849 * recheck if adjust WiFi duration.
1850 */
1851 if (m >= 20)
1852 m = 20;
1853
1854 n = 3 * m;
1855 up = 0;
1856 dn = 0;
1857 wait_count = 0;
1858 result = -1;
1859 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1860 "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1861 }
1862 } else {
1863 /* retry count > 3, if retry count > 3 happens once,
1864 * shrink WiFi duration
1865 */
1866 if (wait_count == 1)
1867 m++; /* avoid bounce in two levels */
1868 else
1869 m = 1;
1870 /* m max value is 20, max time is 120 second,
1871 * recheck if adjust WiFi duration.
1872 */
1873 if (m >= 20)
1874 m = 20;
1875
1876 n = 3 * m;
1877 up = 0;
1878 dn = 0;
1879 wait_count = 0;
1880 result = -1;
1881 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1882 "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1883 }
1884
1885 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1886 "[BTCoex], max Interval = %d\n", max_interval);
1887
1888 if (max_interval == 1) {
1889 if (tx_pause) {
1890 if (coex_dm->cur_ps_tdma == 71) {
1891 btc8821a2ant_ps_tdma(btcoexist,
1892 NORMAL_EXEC, true, 5);
1893 coex_dm->ps_tdma_du_adj_type = 5;
1894 } else if (coex_dm->cur_ps_tdma == 1) {
1895 btc8821a2ant_ps_tdma(btcoexist,
1896 NORMAL_EXEC, true, 5);
1897 coex_dm->ps_tdma_du_adj_type = 5;
1898 } else if (coex_dm->cur_ps_tdma == 2) {
1899 btc8821a2ant_ps_tdma(btcoexist,
1900 NORMAL_EXEC, true, 6);
1901 coex_dm->ps_tdma_du_adj_type = 6;
1902 } else if (coex_dm->cur_ps_tdma == 3) {
1903 btc8821a2ant_ps_tdma(btcoexist,
1904 NORMAL_EXEC, true, 7);
1905 coex_dm->ps_tdma_du_adj_type = 7;
1906 } else if (coex_dm->cur_ps_tdma == 4) {
1907 btc8821a2ant_ps_tdma(btcoexist,
1908 NORMAL_EXEC, true, 8);
1909 coex_dm->ps_tdma_du_adj_type = 8;
1910 }
1911 if (coex_dm->cur_ps_tdma == 9) {
1912 btc8821a2ant_ps_tdma(btcoexist,
1913 NORMAL_EXEC, true, 13);
1914 coex_dm->ps_tdma_du_adj_type = 13;
1915 } else if (coex_dm->cur_ps_tdma == 10) {
1916 btc8821a2ant_ps_tdma(btcoexist,
1917 NORMAL_EXEC, true, 14);
1918 coex_dm->ps_tdma_du_adj_type = 14;
1919 } else if (coex_dm->cur_ps_tdma == 11) {
1920 btc8821a2ant_ps_tdma(btcoexist,
1921 NORMAL_EXEC, true, 15);
1922 coex_dm->ps_tdma_du_adj_type = 15;
1923 } else if (coex_dm->cur_ps_tdma == 12) {
1924 btc8821a2ant_ps_tdma(btcoexist,
1925 NORMAL_EXEC, true, 16);
1926 coex_dm->ps_tdma_du_adj_type = 16;
1927 }
1928
1929 if (result == -1) {
1930 if (coex_dm->cur_ps_tdma == 5) {
1931 btc8821a2ant_ps_tdma(
1932 btcoexist, NORMAL_EXEC,
1933 true, 6);
1934 coex_dm->ps_tdma_du_adj_type =
1935 6;
1936 } else if (coex_dm->cur_ps_tdma == 6) {
1937 btc8821a2ant_ps_tdma(
1938 btcoexist, NORMAL_EXEC,
1939 true, 7);
1940 coex_dm->ps_tdma_du_adj_type =
1941 7;
1942 } else if (coex_dm->cur_ps_tdma == 7) {
1943 btc8821a2ant_ps_tdma(
1944 btcoexist, NORMAL_EXEC,
1945 true, 8);
1946 coex_dm->ps_tdma_du_adj_type =
1947 8;
1948 } else if (coex_dm->cur_ps_tdma == 13) {
1949 btc8821a2ant_ps_tdma(
1950 btcoexist, NORMAL_EXEC,
1951 true, 14);
1952 coex_dm->ps_tdma_du_adj_type =
1953 14;
1954 } else if (coex_dm->cur_ps_tdma == 14) {
1955 btc8821a2ant_ps_tdma(
1956 btcoexist, NORMAL_EXEC,
1957 true, 15);
1958 coex_dm->ps_tdma_du_adj_type =
1959 15;
1960 } else if (coex_dm->cur_ps_tdma == 15) {
1961 btc8821a2ant_ps_tdma(
1962 btcoexist, NORMAL_EXEC,
1963 true, 16);
1964 coex_dm->ps_tdma_du_adj_type =
1965 16;
1966 }
1967 } else if (result == 1) {
1968 if (coex_dm->cur_ps_tdma == 8) {
1969 btc8821a2ant_ps_tdma(
1970 btcoexist, NORMAL_EXEC,
1971 true, 7);
1972 coex_dm->ps_tdma_du_adj_type =
1973 7;
1974 } else if (coex_dm->cur_ps_tdma == 7) {
1975 btc8821a2ant_ps_tdma(
1976 btcoexist, NORMAL_EXEC,
1977 true, 6);
1978 coex_dm->ps_tdma_du_adj_type =
1979 6;
1980 } else if (coex_dm->cur_ps_tdma == 6) {
1981 btc8821a2ant_ps_tdma(
1982 btcoexist, NORMAL_EXEC,
1983 true, 5);
1984 coex_dm->ps_tdma_du_adj_type =
1985 5;
1986 } else if (coex_dm->cur_ps_tdma == 16) {
1987 btc8821a2ant_ps_tdma(
1988 btcoexist, NORMAL_EXEC,
1989 true, 15);
1990 coex_dm->ps_tdma_du_adj_type =
1991 15;
1992 } else if (coex_dm->cur_ps_tdma == 15) {
1993 btc8821a2ant_ps_tdma(
1994 btcoexist, NORMAL_EXEC,
1995 true, 14);
1996 coex_dm->ps_tdma_du_adj_type =
1997 14;
1998 } else if (coex_dm->cur_ps_tdma == 14) {
1999 btc8821a2ant_ps_tdma(
2000 btcoexist, NORMAL_EXEC,
2001 true, 13);
2002 coex_dm->ps_tdma_du_adj_type =
2003 13;
2004 }
2005 }
2006 } else {
2007 if (coex_dm->cur_ps_tdma == 5) {
2008 btc8821a2ant_ps_tdma(btcoexist,
2009 NORMAL_EXEC, true, 71);
2010 coex_dm->ps_tdma_du_adj_type = 71;
2011 } else if (coex_dm->cur_ps_tdma == 6) {
2012 btc8821a2ant_ps_tdma(btcoexist,
2013 NORMAL_EXEC, true, 2);
2014 coex_dm->ps_tdma_du_adj_type = 2;
2015 } else if (coex_dm->cur_ps_tdma == 7) {
2016 btc8821a2ant_ps_tdma(btcoexist,
2017 NORMAL_EXEC, true, 3);
2018 coex_dm->ps_tdma_du_adj_type = 3;
2019 } else if (coex_dm->cur_ps_tdma == 8) {
2020 btc8821a2ant_ps_tdma(btcoexist,
2021 NORMAL_EXEC, true, 4);
2022 coex_dm->ps_tdma_du_adj_type = 4;
2023 }
2024 if (coex_dm->cur_ps_tdma == 13) {
2025 btc8821a2ant_ps_tdma(btcoexist,
2026 NORMAL_EXEC, true, 9);
2027 coex_dm->ps_tdma_du_adj_type = 9;
2028 } else if (coex_dm->cur_ps_tdma == 14) {
2029 btc8821a2ant_ps_tdma(btcoexist,
2030 NORMAL_EXEC, true, 10);
2031 coex_dm->ps_tdma_du_adj_type = 10;
2032 } else if (coex_dm->cur_ps_tdma == 15) {
2033 btc8821a2ant_ps_tdma(btcoexist,
2034 NORMAL_EXEC, true, 11);
2035 coex_dm->ps_tdma_du_adj_type = 11;
2036 } else if (coex_dm->cur_ps_tdma == 16) {
2037 btc8821a2ant_ps_tdma(btcoexist,
2038 NORMAL_EXEC, true, 12);
2039 coex_dm->ps_tdma_du_adj_type = 12;
2040 }
2041
2042 if (result == -1) {
2043 if (coex_dm->cur_ps_tdma == 71) {
2044 btc8821a2ant_ps_tdma(
2045 btcoexist, NORMAL_EXEC,
2046 true, 1);
2047 coex_dm->ps_tdma_du_adj_type =
2048 1;
2049 } else if (coex_dm->cur_ps_tdma == 1) {
2050 btc8821a2ant_ps_tdma(
2051 btcoexist, NORMAL_EXEC,
2052 true, 2);
2053 coex_dm->ps_tdma_du_adj_type =
2054 2;
2055 } else if (coex_dm->cur_ps_tdma == 2) {
2056 btc8821a2ant_ps_tdma(
2057 btcoexist, NORMAL_EXEC,
2058 true, 3);
2059 coex_dm->ps_tdma_du_adj_type =
2060 3;
2061 } else if (coex_dm->cur_ps_tdma == 3) {
2062 btc8821a2ant_ps_tdma(
2063 btcoexist, NORMAL_EXEC,
2064 true, 4);
2065 coex_dm->ps_tdma_du_adj_type =
2066 4;
2067 } else if (coex_dm->cur_ps_tdma == 9) {
2068 btc8821a2ant_ps_tdma(
2069 btcoexist, NORMAL_EXEC,
2070 true, 10);
2071 coex_dm->ps_tdma_du_adj_type =
2072 10;
2073 } else if (coex_dm->cur_ps_tdma == 10) {
2074 btc8821a2ant_ps_tdma(
2075 btcoexist, NORMAL_EXEC,
2076 true, 11);
2077 coex_dm->ps_tdma_du_adj_type =
2078 11;
2079 } else if (coex_dm->cur_ps_tdma == 11) {
2080 btc8821a2ant_ps_tdma(
2081 btcoexist, NORMAL_EXEC,
2082 true, 12);
2083 coex_dm->ps_tdma_du_adj_type =
2084 12;
2085 }
2086 } else if (result == 1) {
2087 if (coex_dm->cur_ps_tdma == 4) {
2088 btc8821a2ant_ps_tdma(
2089 btcoexist, NORMAL_EXEC,
2090 true, 3);
2091 coex_dm->ps_tdma_du_adj_type =
2092 3;
2093 } else if (coex_dm->cur_ps_tdma == 3) {
2094 btc8821a2ant_ps_tdma(
2095 btcoexist, NORMAL_EXEC,
2096 true, 2);
2097 coex_dm->ps_tdma_du_adj_type =
2098 2;
2099 } else if (coex_dm->cur_ps_tdma == 2) {
2100 btc8821a2ant_ps_tdma(
2101 btcoexist, NORMAL_EXEC,
2102 true, 1);
2103 coex_dm->ps_tdma_du_adj_type =
2104 1;
2105 } else if (coex_dm->cur_ps_tdma == 1) {
2106 btc8821a2ant_ps_tdma(
2107 btcoexist, NORMAL_EXEC,
2108 true, 71);
2109 coex_dm->ps_tdma_du_adj_type =
2110 71;
2111 } else if (coex_dm->cur_ps_tdma == 12) {
2112 btc8821a2ant_ps_tdma(
2113 btcoexist, NORMAL_EXEC,
2114 true, 11);
2115 coex_dm->ps_tdma_du_adj_type =
2116 11;
2117 } else if (coex_dm->cur_ps_tdma == 11) {
2118 btc8821a2ant_ps_tdma(
2119 btcoexist, NORMAL_EXEC,
2120 true, 10);
2121 coex_dm->ps_tdma_du_adj_type =
2122 10;
2123 } else if (coex_dm->cur_ps_tdma == 10) {
2124 btc8821a2ant_ps_tdma(
2125 btcoexist, NORMAL_EXEC,
2126 true, 9);
2127 coex_dm->ps_tdma_du_adj_type =
2128 9;
2129 }
2130 }
2131 }
2132 } else if (max_interval == 2) {
2133 if (tx_pause) {
2134 if (coex_dm->cur_ps_tdma == 1) {
2135 btc8821a2ant_ps_tdma(btcoexist,
2136 NORMAL_EXEC, true, 6);
2137 coex_dm->ps_tdma_du_adj_type = 6;
2138 } else if (coex_dm->cur_ps_tdma == 2) {
2139 btc8821a2ant_ps_tdma(btcoexist,
2140 NORMAL_EXEC, true, 6);
2141 coex_dm->ps_tdma_du_adj_type = 6;
2142 } else if (coex_dm->cur_ps_tdma == 3) {
2143 btc8821a2ant_ps_tdma(btcoexist,
2144 NORMAL_EXEC, true, 7);
2145 coex_dm->ps_tdma_du_adj_type = 7;
2146 } else if (coex_dm->cur_ps_tdma == 4) {
2147 btc8821a2ant_ps_tdma(btcoexist,
2148 NORMAL_EXEC, true, 8);
2149 coex_dm->ps_tdma_du_adj_type = 8;
2150 }
2151 if (coex_dm->cur_ps_tdma == 9) {
2152 btc8821a2ant_ps_tdma(btcoexist,
2153 NORMAL_EXEC, true, 14);
2154 coex_dm->ps_tdma_du_adj_type = 14;
2155 } else if (coex_dm->cur_ps_tdma == 10) {
2156 btc8821a2ant_ps_tdma(btcoexist,
2157 NORMAL_EXEC, true, 14);
2158 coex_dm->ps_tdma_du_adj_type = 14;
2159 } else if (coex_dm->cur_ps_tdma == 11) {
2160 btc8821a2ant_ps_tdma(btcoexist,
2161 NORMAL_EXEC, true, 15);
2162 coex_dm->ps_tdma_du_adj_type = 15;
2163 } else if (coex_dm->cur_ps_tdma == 12) {
2164 btc8821a2ant_ps_tdma(btcoexist,
2165 NORMAL_EXEC, true, 16);
2166 coex_dm->ps_tdma_du_adj_type = 16;
2167 }
2168 if (result == -1) {
2169 if (coex_dm->cur_ps_tdma == 5) {
2170 btc8821a2ant_ps_tdma(
2171 btcoexist, NORMAL_EXEC,
2172 true, 6);
2173 coex_dm->ps_tdma_du_adj_type =
2174 6;
2175 } else if (coex_dm->cur_ps_tdma == 6) {
2176 btc8821a2ant_ps_tdma(
2177 btcoexist, NORMAL_EXEC,
2178 true, 7);
2179 coex_dm->ps_tdma_du_adj_type =
2180 7;
2181 } else if (coex_dm->cur_ps_tdma == 7) {
2182 btc8821a2ant_ps_tdma(
2183 btcoexist, NORMAL_EXEC,
2184 true, 8);
2185 coex_dm->ps_tdma_du_adj_type =
2186 8;
2187 } else if (coex_dm->cur_ps_tdma == 13) {
2188 btc8821a2ant_ps_tdma(
2189 btcoexist, NORMAL_EXEC,
2190 true, 14);
2191 coex_dm->ps_tdma_du_adj_type =
2192 14;
2193 } else if (coex_dm->cur_ps_tdma == 14) {
2194 btc8821a2ant_ps_tdma(
2195 btcoexist, NORMAL_EXEC,
2196 true, 15);
2197 coex_dm->ps_tdma_du_adj_type =
2198 15;
2199 } else if (coex_dm->cur_ps_tdma == 15) {
2200 btc8821a2ant_ps_tdma(
2201 btcoexist, NORMAL_EXEC,
2202 true, 16);
2203 coex_dm->ps_tdma_du_adj_type =
2204 16;
2205 }
2206 } else if (result == 1) {
2207 if (coex_dm->cur_ps_tdma == 8) {
2208 btc8821a2ant_ps_tdma(
2209 btcoexist, NORMAL_EXEC,
2210 true, 7);
2211 coex_dm->ps_tdma_du_adj_type =
2212 7;
2213 } else if (coex_dm->cur_ps_tdma == 7) {
2214 btc8821a2ant_ps_tdma(
2215 btcoexist, NORMAL_EXEC,
2216 true, 6);
2217 coex_dm->ps_tdma_du_adj_type =
2218 6;
2219 } else if (coex_dm->cur_ps_tdma == 6) {
2220 btc8821a2ant_ps_tdma(
2221 btcoexist, NORMAL_EXEC,
2222 true, 6);
2223 coex_dm->ps_tdma_du_adj_type =
2224 6;
2225 } else if (coex_dm->cur_ps_tdma == 16) {
2226 btc8821a2ant_ps_tdma(
2227 btcoexist, NORMAL_EXEC,
2228 true, 15);
2229 coex_dm->ps_tdma_du_adj_type =
2230 15;
2231 } else if (coex_dm->cur_ps_tdma == 15) {
2232 btc8821a2ant_ps_tdma(
2233 btcoexist, NORMAL_EXEC,
2234 true, 14);
2235 coex_dm->ps_tdma_du_adj_type =
2236 14;
2237 } else if (coex_dm->cur_ps_tdma == 14) {
2238 btc8821a2ant_ps_tdma(
2239 btcoexist, NORMAL_EXEC,
2240 true, 14);
2241 coex_dm->ps_tdma_du_adj_type =
2242 14;
2243 }
2244 }
2245 } else {
2246 if (coex_dm->cur_ps_tdma == 5) {
2247 btc8821a2ant_ps_tdma(btcoexist,
2248 NORMAL_EXEC, true, 2);
2249 coex_dm->ps_tdma_du_adj_type = 2;
2250 } else if (coex_dm->cur_ps_tdma == 6) {
2251 btc8821a2ant_ps_tdma(btcoexist,
2252 NORMAL_EXEC, true, 2);
2253 coex_dm->ps_tdma_du_adj_type = 2;
2254 } else if (coex_dm->cur_ps_tdma == 7) {
2255 btc8821a2ant_ps_tdma(btcoexist,
2256 NORMAL_EXEC, true, 3);
2257 coex_dm->ps_tdma_du_adj_type = 3;
2258 } else if (coex_dm->cur_ps_tdma == 8) {
2259 btc8821a2ant_ps_tdma(btcoexist,
2260 NORMAL_EXEC, true, 4);
2261 coex_dm->ps_tdma_du_adj_type = 4;
2262 }
2263 if (coex_dm->cur_ps_tdma == 13) {
2264 btc8821a2ant_ps_tdma(btcoexist,
2265 NORMAL_EXEC, true, 10);
2266 coex_dm->ps_tdma_du_adj_type = 10;
2267 } else if (coex_dm->cur_ps_tdma == 14) {
2268 btc8821a2ant_ps_tdma(btcoexist,
2269 NORMAL_EXEC, true, 10);
2270 coex_dm->ps_tdma_du_adj_type = 10;
2271 } else if (coex_dm->cur_ps_tdma == 15) {
2272 btc8821a2ant_ps_tdma(btcoexist,
2273 NORMAL_EXEC, true, 11);
2274 coex_dm->ps_tdma_du_adj_type = 11;
2275 } else if (coex_dm->cur_ps_tdma == 16) {
2276 btc8821a2ant_ps_tdma(btcoexist,
2277 NORMAL_EXEC, true, 12);
2278 coex_dm->ps_tdma_du_adj_type = 12;
2279 }
2280 if (result == -1) {
2281 if (coex_dm->cur_ps_tdma == 1) {
2282 btc8821a2ant_ps_tdma(
2283 btcoexist, NORMAL_EXEC,
2284 true, 2);
2285 coex_dm->ps_tdma_du_adj_type =
2286 2;
2287 } else if (coex_dm->cur_ps_tdma == 2) {
2288 btc8821a2ant_ps_tdma(
2289 btcoexist, NORMAL_EXEC,
2290 true, 3);
2291 coex_dm->ps_tdma_du_adj_type =
2292 3;
2293 } else if (coex_dm->cur_ps_tdma == 3) {
2294 btc8821a2ant_ps_tdma(
2295 btcoexist, NORMAL_EXEC,
2296 true, 4);
2297 coex_dm->ps_tdma_du_adj_type =
2298 4;
2299 } else if (coex_dm->cur_ps_tdma == 9) {
2300 btc8821a2ant_ps_tdma(
2301 btcoexist, NORMAL_EXEC,
2302 true, 10);
2303 coex_dm->ps_tdma_du_adj_type =
2304 10;
2305 } else if (coex_dm->cur_ps_tdma == 10) {
2306 btc8821a2ant_ps_tdma(
2307 btcoexist, NORMAL_EXEC,
2308 true, 11);
2309 coex_dm->ps_tdma_du_adj_type =
2310 11;
2311 } else if (coex_dm->cur_ps_tdma == 11) {
2312 btc8821a2ant_ps_tdma(
2313 btcoexist, NORMAL_EXEC,
2314 true, 12);
2315 coex_dm->ps_tdma_du_adj_type =
2316 12;
2317 }
2318 } else if (result == 1) {
2319 if (coex_dm->cur_ps_tdma == 4) {
2320 btc8821a2ant_ps_tdma(
2321 btcoexist, NORMAL_EXEC,
2322 true, 3);
2323 coex_dm->ps_tdma_du_adj_type =
2324 3;
2325 } else if (coex_dm->cur_ps_tdma == 3) {
2326 btc8821a2ant_ps_tdma(
2327 btcoexist, NORMAL_EXEC,
2328 true, 2);
2329 coex_dm->ps_tdma_du_adj_type =
2330 2;
2331 } else if (coex_dm->cur_ps_tdma == 2) {
2332 btc8821a2ant_ps_tdma(
2333 btcoexist, NORMAL_EXEC,
2334 true, 2);
2335 coex_dm->ps_tdma_du_adj_type =
2336 2;
2337 } else if (coex_dm->cur_ps_tdma == 12) {
2338 btc8821a2ant_ps_tdma(
2339 btcoexist, NORMAL_EXEC,
2340 true, 11);
2341 coex_dm->ps_tdma_du_adj_type =
2342 11;
2343 } else if (coex_dm->cur_ps_tdma == 11) {
2344 btc8821a2ant_ps_tdma(
2345 btcoexist, NORMAL_EXEC,
2346 true, 10);
2347 coex_dm->ps_tdma_du_adj_type =
2348 10;
2349 } else if (coex_dm->cur_ps_tdma == 10) {
2350 btc8821a2ant_ps_tdma(
2351 btcoexist, NORMAL_EXEC,
2352 true, 10);
2353 coex_dm->ps_tdma_du_adj_type =
2354 10;
2355 }
2356 }
2357 }
2358 } else if (max_interval == 3) {
2359 if (tx_pause) {
2360 if (coex_dm->cur_ps_tdma == 1) {
2361 btc8821a2ant_ps_tdma(btcoexist,
2362 NORMAL_EXEC, true, 7);
2363 coex_dm->ps_tdma_du_adj_type = 7;
2364 } else if (coex_dm->cur_ps_tdma == 2) {
2365 btc8821a2ant_ps_tdma(btcoexist,
2366 NORMAL_EXEC, true, 7);
2367 coex_dm->ps_tdma_du_adj_type = 7;
2368 } else if (coex_dm->cur_ps_tdma == 3) {
2369 btc8821a2ant_ps_tdma(btcoexist,
2370 NORMAL_EXEC, true, 7);
2371 coex_dm->ps_tdma_du_adj_type = 7;
2372 } else if (coex_dm->cur_ps_tdma == 4) {
2373 btc8821a2ant_ps_tdma(btcoexist,
2374 NORMAL_EXEC, true, 8);
2375 coex_dm->ps_tdma_du_adj_type = 8;
2376 }
2377 if (coex_dm->cur_ps_tdma == 9) {
2378 btc8821a2ant_ps_tdma(btcoexist,
2379 NORMAL_EXEC, true, 15);
2380 coex_dm->ps_tdma_du_adj_type = 15;
2381 } else if (coex_dm->cur_ps_tdma == 10) {
2382 btc8821a2ant_ps_tdma(btcoexist,
2383 NORMAL_EXEC, true, 15);
2384 coex_dm->ps_tdma_du_adj_type = 15;
2385 } else if (coex_dm->cur_ps_tdma == 11) {
2386 btc8821a2ant_ps_tdma(btcoexist,
2387 NORMAL_EXEC, true, 15);
2388 coex_dm->ps_tdma_du_adj_type = 15;
2389 } else if (coex_dm->cur_ps_tdma == 12) {
2390 btc8821a2ant_ps_tdma(btcoexist,
2391 NORMAL_EXEC, true, 16);
2392 coex_dm->ps_tdma_du_adj_type = 16;
2393 }
2394 if (result == -1) {
2395 if (coex_dm->cur_ps_tdma == 5) {
2396 btc8821a2ant_ps_tdma(
2397 btcoexist, NORMAL_EXEC,
2398 true, 7);
2399 coex_dm->ps_tdma_du_adj_type =
2400 7;
2401 } else if (coex_dm->cur_ps_tdma == 6) {
2402 btc8821a2ant_ps_tdma(
2403 btcoexist, NORMAL_EXEC,
2404 true, 7);
2405 coex_dm->ps_tdma_du_adj_type =
2406 7;
2407 } else if (coex_dm->cur_ps_tdma == 7) {
2408 btc8821a2ant_ps_tdma(
2409 btcoexist, NORMAL_EXEC,
2410 true, 8);
2411 coex_dm->ps_tdma_du_adj_type =
2412 8;
2413 } else if (coex_dm->cur_ps_tdma == 13) {
2414 btc8821a2ant_ps_tdma(
2415 btcoexist, NORMAL_EXEC,
2416 true, 15);
2417 coex_dm->ps_tdma_du_adj_type =
2418 15;
2419 } else if (coex_dm->cur_ps_tdma == 14) {
2420 btc8821a2ant_ps_tdma(
2421 btcoexist, NORMAL_EXEC,
2422 true, 15);
2423 coex_dm->ps_tdma_du_adj_type =
2424 15;
2425 } else if (coex_dm->cur_ps_tdma == 15) {
2426 btc8821a2ant_ps_tdma(
2427 btcoexist, NORMAL_EXEC,
2428 true, 16);
2429 coex_dm->ps_tdma_du_adj_type =
2430 16;
2431 }
2432 } else if (result == 1) {
2433 if (coex_dm->cur_ps_tdma == 8) {
2434 btc8821a2ant_ps_tdma(
2435 btcoexist, NORMAL_EXEC,
2436 true, 7);
2437 coex_dm->ps_tdma_du_adj_type =
2438 7;
2439 } else if (coex_dm->cur_ps_tdma == 7) {
2440 btc8821a2ant_ps_tdma(
2441 btcoexist, NORMAL_EXEC,
2442 true, 7);
2443 coex_dm->ps_tdma_du_adj_type =
2444 7;
2445 } else if (coex_dm->cur_ps_tdma == 6) {
2446 btc8821a2ant_ps_tdma(
2447 btcoexist, NORMAL_EXEC,
2448 true, 7);
2449 coex_dm->ps_tdma_du_adj_type =
2450 7;
2451 } else if (coex_dm->cur_ps_tdma == 16) {
2452 btc8821a2ant_ps_tdma(
2453 btcoexist, NORMAL_EXEC,
2454 true, 15);
2455 coex_dm->ps_tdma_du_adj_type =
2456 15;
2457 } else if (coex_dm->cur_ps_tdma == 15) {
2458 btc8821a2ant_ps_tdma(
2459 btcoexist, NORMAL_EXEC,
2460 true, 15);
2461 coex_dm->ps_tdma_du_adj_type =
2462 15;
2463 } else if (coex_dm->cur_ps_tdma == 14) {
2464 btc8821a2ant_ps_tdma(
2465 btcoexist, NORMAL_EXEC,
2466 true, 15);
2467 coex_dm->ps_tdma_du_adj_type =
2468 15;
2469 }
2470 }
2471 } else {
2472 if (coex_dm->cur_ps_tdma == 5) {
2473 btc8821a2ant_ps_tdma(btcoexist,
2474 NORMAL_EXEC, true, 3);
2475 coex_dm->ps_tdma_du_adj_type = 3;
2476 } else if (coex_dm->cur_ps_tdma == 6) {
2477 btc8821a2ant_ps_tdma(btcoexist,
2478 NORMAL_EXEC, true, 3);
2479 coex_dm->ps_tdma_du_adj_type = 3;
2480 } else if (coex_dm->cur_ps_tdma == 7) {
2481 btc8821a2ant_ps_tdma(btcoexist,
2482 NORMAL_EXEC, true, 3);
2483 coex_dm->ps_tdma_du_adj_type = 3;
2484 } else if (coex_dm->cur_ps_tdma == 8) {
2485 btc8821a2ant_ps_tdma(btcoexist,
2486 NORMAL_EXEC, true, 4);
2487 coex_dm->ps_tdma_du_adj_type = 4;
2488 }
2489 if (coex_dm->cur_ps_tdma == 13) {
2490 btc8821a2ant_ps_tdma(btcoexist,
2491 NORMAL_EXEC, true, 11);
2492 coex_dm->ps_tdma_du_adj_type = 11;
2493 } else if (coex_dm->cur_ps_tdma == 14) {
2494 btc8821a2ant_ps_tdma(btcoexist,
2495 NORMAL_EXEC, true, 11);
2496 coex_dm->ps_tdma_du_adj_type = 11;
2497 } else if (coex_dm->cur_ps_tdma == 15) {
2498 btc8821a2ant_ps_tdma(btcoexist,
2499 NORMAL_EXEC, true, 11);
2500 coex_dm->ps_tdma_du_adj_type = 11;
2501 } else if (coex_dm->cur_ps_tdma == 16) {
2502 btc8821a2ant_ps_tdma(btcoexist,
2503 NORMAL_EXEC, true, 12);
2504 coex_dm->ps_tdma_du_adj_type = 12;
2505 }
2506 if (result == -1) {
2507 if (coex_dm->cur_ps_tdma == 1) {
2508 btc8821a2ant_ps_tdma(
2509 btcoexist, NORMAL_EXEC,
2510 true, 3);
2511 coex_dm->ps_tdma_du_adj_type =
2512 3;
2513 } else if (coex_dm->cur_ps_tdma == 2) {
2514 btc8821a2ant_ps_tdma(
2515 btcoexist, NORMAL_EXEC,
2516 true, 3);
2517 coex_dm->ps_tdma_du_adj_type =
2518 3;
2519 } else if (coex_dm->cur_ps_tdma == 3) {
2520 btc8821a2ant_ps_tdma(
2521 btcoexist, NORMAL_EXEC,
2522 true, 4);
2523 coex_dm->ps_tdma_du_adj_type =
2524 4;
2525 } else if (coex_dm->cur_ps_tdma == 9) {
2526 btc8821a2ant_ps_tdma(
2527 btcoexist, NORMAL_EXEC,
2528 true, 11);
2529 coex_dm->ps_tdma_du_adj_type =
2530 11;
2531 } else if (coex_dm->cur_ps_tdma == 10) {
2532 btc8821a2ant_ps_tdma(
2533 btcoexist, NORMAL_EXEC,
2534 true, 11);
2535 coex_dm->ps_tdma_du_adj_type =
2536 11;
2537 } else if (coex_dm->cur_ps_tdma == 11) {
2538 btc8821a2ant_ps_tdma(
2539 btcoexist, NORMAL_EXEC,
2540 true, 12);
2541 coex_dm->ps_tdma_du_adj_type =
2542 12;
2543 }
2544 } else if (result == 1) {
2545 if (coex_dm->cur_ps_tdma == 4) {
2546 btc8821a2ant_ps_tdma(
2547 btcoexist, NORMAL_EXEC,
2548 true, 3);
2549 coex_dm->ps_tdma_du_adj_type =
2550 3;
2551 } else if (coex_dm->cur_ps_tdma == 3) {
2552 btc8821a2ant_ps_tdma(
2553 btcoexist, NORMAL_EXEC,
2554 true, 3);
2555 coex_dm->ps_tdma_du_adj_type =
2556 3;
2557 } else if (coex_dm->cur_ps_tdma == 2) {
2558 btc8821a2ant_ps_tdma(
2559 btcoexist, NORMAL_EXEC,
2560 true, 3);
2561 coex_dm->ps_tdma_du_adj_type =
2562 3;
2563 } else if (coex_dm->cur_ps_tdma == 12) {
2564 btc8821a2ant_ps_tdma(
2565 btcoexist, NORMAL_EXEC,
2566 true, 11);
2567 coex_dm->ps_tdma_du_adj_type =
2568 11;
2569 } else if (coex_dm->cur_ps_tdma == 11) {
2570 btc8821a2ant_ps_tdma(
2571 btcoexist, NORMAL_EXEC,
2572 true, 11);
2573 coex_dm->ps_tdma_du_adj_type =
2574 11;
2575 } else if (coex_dm->cur_ps_tdma == 10) {
2576 btc8821a2ant_ps_tdma(
2577 btcoexist, NORMAL_EXEC,
2578 true, 11);
2579 coex_dm->ps_tdma_du_adj_type =
2580 11;
2581 }
2582 }
2583 }
2584 }
2585 }
2586
2587 /* if current PsTdma not match with the recorded one
2588 * (when scan, dhcp...), then we have to adjust it back to
2589 * the previous recorded one.
2590 */
2591 if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2592 bool scan = false, link = false, roam = false;
2593
2594 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2595 "[BTCoex], PsTdma type mismatch!!!, cur_ps_tdma = %d, recordPsTdma = %d\n",
2596 coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2597
2598 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2599 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2600 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2601
2602 if (!scan && !link && !roam) {
2603 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2604 coex_dm->ps_tdma_du_adj_type);
2605 } else {
2606 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2607 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2608 }
2609 }
2610 }
2611
2612 /* SCO only or SCO+PAN(HS)*/
2613 static void btc8821a2ant_action_sco(struct btc_coexist *btcoexist)
2614 {
2615 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2616 u8 wifi_rssi_state, bt_rssi_state;
2617 u32 wifi_bw;
2618
2619 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2620 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist, 2, 35, 0);
2621
2622 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2623
2624 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2625 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2626
2627 if (BTC_RSSI_HIGH(bt_rssi_state))
2628 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2629 else
2630 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2631
2632 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2633
2634 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
2635 /* for SCO quality at 11b/g mode */
2636 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2637 } else {
2638 /* for SCO quality & wifi performance balance at 11n mode */
2639 if (wifi_bw == BTC_WIFI_BW_HT40) {
2640 btc8821a2ant_coex_table_with_type(btcoexist,
2641 NORMAL_EXEC, 8);
2642 } else {
2643 if (bt_link_info->sco_only)
2644 btc8821a2ant_coex_table_with_type(
2645 btcoexist, NORMAL_EXEC, 17);
2646 else
2647 btc8821a2ant_coex_table_with_type(
2648 btcoexist, NORMAL_EXEC, 12);
2649 }
2650 }
2651
2652 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2653 /* for voice quality */
2654 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2655
2656 /* sw mechanism */
2657 if (wifi_bw == BTC_WIFI_BW_HT40) {
2658 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2659 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2660 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2661 false, false);
2662 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2663 true, 0x18);
2664 } else {
2665 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2666 false, false);
2667 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2668 true, 0x18);
2669 }
2670 } else {
2671 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2672 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2673 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2674 false, false);
2675 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2676 true, 0x18);
2677 } else {
2678 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2679 false, false);
2680 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2681 true, 0x18);
2682 }
2683 }
2684 }
2685
2686 static void btc8821a2ant_action_hid(struct btc_coexist *btcoexist)
2687 {
2688 u8 wifi_rssi_state, bt_rssi_state;
2689 u32 wifi_bw;
2690
2691 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2692 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2693 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2694
2695 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2696
2697 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2698 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2699
2700 if (BTC_RSSI_HIGH(bt_rssi_state))
2701 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2702 else
2703 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2704
2705 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2706
2707 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
2708 /* for HID at 11b/g mode */
2709 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2710 } else {
2711 /* for HID quality & wifi performance balance at 11n mode */
2712 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2713 }
2714
2715 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2716 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 24);
2717
2718 if (wifi_bw == BTC_WIFI_BW_HT40) {
2719 /* sw mechanism */
2720 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2721 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2722 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2723 false, false);
2724 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2725 false, 0x18);
2726 } else {
2727 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2728 false, false);
2729 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2730 false, 0x18);
2731 }
2732 } else {
2733 /* sw mechanism */
2734 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2735 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2736 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2737 false, false);
2738 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2739 false, 0x18);
2740 } else {
2741 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2742 false, false);
2743 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2744 false, 0x18);
2745 }
2746 }
2747 }
2748
2749 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2750 static void btc8821a2ant_action_a2dp(struct btc_coexist *btcoexist)
2751 {
2752 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2753 u8 ap_num = 0;
2754 u32 wifi_bw;
2755
2756 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2757 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2758 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2759 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2760 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2761
2762 if ((ap_num >= 10) && BTC_RSSI_HIGH(wifi_rssi_state1) &&
2763 BTC_RSSI_HIGH(bt_rssi_state)) {
2764 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2765 0x0, 0x0);
2766
2767 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2768 0x0);
2769 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2770 0x8);
2771 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2772 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2773
2774 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2775
2776 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2777 0x0, 0x0);
2778 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2779
2780 /* sw mechanism */
2781 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2782 if (wifi_bw == BTC_WIFI_BW_HT40) {
2783 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2784 false, false);
2785 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2786 true, 0x6);
2787 } else {
2788 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2789 false, false);
2790 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2791 true, 0x6);
2792 }
2793 return;
2794 }
2795
2796 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2797 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2798
2799 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2800
2801 if (BTC_RSSI_HIGH(bt_rssi_state))
2802 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2803 else
2804 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2805
2806 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2807 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2808 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2809 0x0, 0x0);
2810 } else {
2811 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2812 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2813 0x4);
2814 }
2815
2816 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2817 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2818 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2819 } else {
2820 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2821 }
2822
2823 /* sw mechanism */
2824 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2825 if (wifi_bw == BTC_WIFI_BW_HT40) {
2826 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2827 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2828 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2829 false, false);
2830 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2831 false, 0x18);
2832 } else {
2833 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2834 false, false);
2835 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2836 false, 0x18);
2837 }
2838 } else {
2839 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2840 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2841 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2842 false, false);
2843 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2844 false, 0x18);
2845 } else {
2846 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2847 false, false);
2848 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2849 false, 0x18);
2850 }
2851 }
2852 }
2853
2854 static void btc8821a2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2855 {
2856 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2857 u32 wifi_bw;
2858
2859 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2860 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2861 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2862 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2863 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2864
2865 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2866
2867 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2868 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2869
2870 if (BTC_RSSI_HIGH(bt_rssi_state))
2871 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2872 else
2873 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2874
2875 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2876 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2877 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2878 0x0, 0x0);
2879 } else {
2880 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2881 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2882 0x4);
2883 }
2884
2885 btc8821a2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2886
2887 /* sw mechanism */
2888 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2889 if (wifi_bw == BTC_WIFI_BW_HT40) {
2890 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2891 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2892 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2893 false, false);
2894 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2895 false, 0x18);
2896 } else {
2897 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2898 false, false);
2899 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2900 false, 0x18);
2901 }
2902 } else {
2903 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2904 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2905 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2906 false, false);
2907 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2908 false, 0x18);
2909 } else {
2910 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2911 false, false);
2912 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2913 false, 0x18);
2914 }
2915 }
2916 }
2917
2918 static void btc8821a2ant_action_pan_edr(struct btc_coexist *btcoexist)
2919 {
2920 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2921 u32 wifi_bw;
2922
2923 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2924 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2925 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2926 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2927 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2928
2929 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2930
2931 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2932
2933 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2934
2935 if (BTC_RSSI_HIGH(bt_rssi_state))
2936 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2937 else
2938 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2939
2940 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2941 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 10);
2942 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2943 0x0, 0x0);
2944 } else {
2945 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2946 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2947 0x4);
2948 }
2949
2950 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2951 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2952 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 26);
2953 else
2954 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 26);
2955
2956 /* sw mechanism */
2957 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2958 if (wifi_bw == BTC_WIFI_BW_HT40) {
2959 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2960 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2961 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2962 false, false);
2963 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2964 false, 0x18);
2965 } else {
2966 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2967 false, false);
2968 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2969 false, 0x18);
2970 }
2971 } else {
2972 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2973 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2974 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2975 false, false);
2976 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2977 false, 0x18);
2978 } else {
2979 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2980 false, false);
2981 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2982 false, 0x18);
2983 }
2984 }
2985 }
2986
2987 /* PAN(HS) only */
2988 static void btc8821a2ant_action_pan_hs(struct btc_coexist *btcoexist)
2989 {
2990 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2991 u32 wifi_bw;
2992
2993 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2994 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2995 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2996 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2997 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2998
2999 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3000
3001 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3002 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3003
3004 if (BTC_RSSI_HIGH(bt_rssi_state))
3005 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3006 else
3007 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3008
3009 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3010 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3011 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3012
3013 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3014 if (wifi_bw == BTC_WIFI_BW_HT40) {
3015 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3016 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3017 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3018 false, false);
3019 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3020 false, 0x18);
3021 } else {
3022 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3023 false, false);
3024 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3025 false, 0x18);
3026 }
3027 } else {
3028 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3029 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3030 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3031 false, false);
3032 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3033 false, 0x18);
3034 } else {
3035 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3036 false, false);
3037 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3038 false, 0x18);
3039 }
3040 }
3041 }
3042
3043 /* PAN(EDR)+A2DP */
3044 static void btc8821a2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
3045 {
3046 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3047 u32 wifi_bw;
3048
3049 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3050 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3051 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3052 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3053 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3054
3055 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3056
3057 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3058
3059 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3060
3061 if (BTC_RSSI_HIGH(bt_rssi_state))
3062 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3063 else
3064 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3065
3066 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state))
3067 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3068 0x0, 0x0);
3069 else
3070 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3071 0x4);
3072
3073 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3074
3075 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3076 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3077 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
3078
3079 if (wifi_bw == BTC_WIFI_BW_HT40)
3080 btc8821a2ant_tdma_duration_adjust(btcoexist, false,
3081 true, 3);
3082 else
3083 btc8821a2ant_tdma_duration_adjust(btcoexist, false,
3084 false, 3);
3085 } else {
3086 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3087 btc8821a2ant_tdma_duration_adjust(btcoexist, false, true, 3);
3088 }
3089
3090 /* sw mechanism */
3091 if (wifi_bw == BTC_WIFI_BW_HT40) {
3092 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3093 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3094 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3095 false, false);
3096 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3097 false, 0x18);
3098 } else {
3099 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3100 false, false);
3101 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3102 false, 0x18);
3103 }
3104 } else {
3105 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3106 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3107 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3108 false, false);
3109 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3110 false, 0x18);
3111 } else {
3112 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3113 false, false);
3114 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3115 false, 0x18);
3116 }
3117 }
3118 }
3119
3120 static void btc8821a2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
3121 {
3122 u8 wifi_rssi_state, bt_rssi_state;
3123 u32 wifi_bw;
3124
3125 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3126 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3127 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3128
3129 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3130
3131 if (BTC_RSSI_HIGH(bt_rssi_state))
3132 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
3133 else
3134 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
3135
3136 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3137
3138 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3139 /* for HID at 11b/g mode */
3140 btc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3141 0x5a5f5a5f, 0xffff, 0x3);
3142 } else {
3143 /* for HID quality & wifi performance balance at 11n mode */
3144 btc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3145 0x5a5f5a5f, 0xffff, 0x3);
3146 }
3147
3148 if (wifi_bw == BTC_WIFI_BW_HT40) {
3149 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 3);
3150 /* fw mechanism */
3151 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3152 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3153 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3154 true, 10);
3155 } else {
3156 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
3157 }
3158
3159 /* sw mechanism */
3160 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3161 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3162 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3163 false, false);
3164 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3165 false, 0x18);
3166 } else {
3167 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3168 false, false);
3169 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3170 false, 0x18);
3171 }
3172 } else {
3173 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3174 /* fw mechanism */
3175 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3176 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3177 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
3178 } else {
3179 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
3180 }
3181
3182 /* sw mechanism */
3183 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3184 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3185 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3186 false, false);
3187 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3188 false, 0x18);
3189 } else {
3190 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3191 false, false);
3192 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3193 false, 0x18);
3194 }
3195 }
3196 }
3197
3198 /* HID+A2DP+PAN(EDR) */
3199 static void btc8821a2ant_act_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
3200 {
3201 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3202 u32 wifi_bw;
3203
3204 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3205 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3206 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3207 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3208 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3209
3210 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3211
3212 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3213 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3214
3215 if (BTC_RSSI_HIGH(bt_rssi_state))
3216 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3217 else
3218 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3219
3220 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3221 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3222 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3223 0x0, 0x0);
3224 } else {
3225 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3226 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3227 0x4);
3228 }
3229
3230 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3231
3232 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3233 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3234 if (wifi_bw == BTC_WIFI_BW_HT40)
3235 btc8821a2ant_tdma_duration_adjust(btcoexist, true,
3236 true, 3);
3237 else
3238 btc8821a2ant_tdma_duration_adjust(btcoexist, true,
3239 false, 3);
3240 } else {
3241 btc8821a2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3242 }
3243
3244 /* sw mechanism */
3245 if (wifi_bw == BTC_WIFI_BW_HT40) {
3246 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3247 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3248 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3249 false, false);
3250 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3251 false, 0x18);
3252 } else {
3253 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3254 false, false);
3255 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3256 false, 0x18);
3257 }
3258 } else {
3259 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3260 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3261 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3262 false, false);
3263 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3264 false, 0x18);
3265 } else {
3266 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3267 false, false);
3268 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3269 false, 0x18);
3270 }
3271 }
3272 }
3273
3274 static void btc8821a2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3275 {
3276 u32 wifi_bw;
3277 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3278 u8 ap_num = 0;
3279
3280 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3281 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3282 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3283 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3284 3, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 37);
3285
3286 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3287
3288 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3289 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3290
3291 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3292 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3293 if (BTC_RSSI_HIGH(bt_rssi_state))
3294 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3295 else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3296 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3297 else
3298 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3299 } else {
3300 /* only 802.11N mode we have to dec bt power to 4 degree */
3301 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3302 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3303 &ap_num);
3304 if (ap_num < 10)
3305 btc8821a2ant_dec_bt_pwr(btcoexist,
3306 NORMAL_EXEC, 4);
3307 else
3308 btc8821a2ant_dec_bt_pwr(btcoexist,
3309 NORMAL_EXEC, 2);
3310 } else if (BTC_RSSI_MEDIUM(bt_rssi_state)) {
3311 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3312 } else {
3313 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3314 }
3315 }
3316
3317 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3318 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3319 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3320 0x0, 0x0);
3321 } else {
3322 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3323 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3324 0x4);
3325 }
3326
3327 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3328 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3329 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
3330 } else {
3331 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
3332 }
3333
3334 /* sw mechanism */
3335 if (wifi_bw == BTC_WIFI_BW_HT40) {
3336 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3337 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3338 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3339 false, false);
3340 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3341 false, 0x18);
3342 } else {
3343 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3344 false, false);
3345 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3346 false, 0x18);
3347 }
3348 } else {
3349 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3350 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3351 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3352 false, false);
3353 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3354 false, 0x18);
3355 } else {
3356 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3357 false, false);
3358 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3359 false, 0x18);
3360 }
3361 }
3362 }
3363
3364 static void btc8821a2ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
3365 {
3366 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3367 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3368
3369 /* sw all off */
3370 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
3371 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
3372
3373 /* hw all off */
3374 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3375
3376 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3377 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3378 }
3379
3380 static void btc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3381 {
3382 struct rtl_priv *rtlpriv = btcoexist->adapter;
3383 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3384 bool wifi_under_5g = false;
3385 u8 algorithm = 0;
3386 u32 num_of_wifi_link = 0;
3387 u32 wifi_link_status = 0;
3388 bool miracast_plus_bt = false;
3389 bool scan = false, link = false, roam = false;
3390
3391 if (btcoexist->manual_control) {
3392 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3393 "[BTCoex], Manual control!!!\n");
3394 return;
3395 }
3396
3397 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3398
3399 if (wifi_under_5g) {
3400 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3401 "[BTCoex], RunCoexistMechanism(), run 5G coex setting!!<===\n");
3402 btc8821a2ant_coex_under_5g(btcoexist);
3403 return;
3404 }
3405
3406 if (coex_sta->under_ips) {
3407 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3408 "[BTCoex], wifi is under IPS !!!\n");
3409 return;
3410 }
3411
3412 algorithm = btc8821a2ant_action_algorithm(btcoexist);
3413 if (coex_sta->c2h_bt_inquiry_page &&
3414 (BT_8821A_2ANT_COEX_ALGO_PANHS != algorithm)) {
3415 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3416 "[BTCoex], BT is under inquiry/page scan !!\n");
3417 btc8821a2ant_action_bt_inquiry(btcoexist);
3418 return;
3419 }
3420
3421 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3422 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3423 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3424
3425 if (scan || link || roam) {
3426 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3427 "[BTCoex], WiFi is under Link Process !!\n");
3428 btc8821a2ant_action_wifi_link_process(btcoexist);
3429 return;
3430 }
3431
3432 /* for P2P */
3433 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3434 &wifi_link_status);
3435 num_of_wifi_link = wifi_link_status >> 16;
3436
3437 if ((num_of_wifi_link >= 2) ||
3438 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3439 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3440 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3441 num_of_wifi_link, wifi_link_status);
3442
3443 if (bt_link_info->bt_link_exist)
3444 miracast_plus_bt = true;
3445 else
3446 miracast_plus_bt = false;
3447
3448 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3449 &miracast_plus_bt);
3450 btc8821a2ant_action_wifi_multi_port(btcoexist);
3451
3452 return;
3453 }
3454
3455 miracast_plus_bt = false;
3456 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3457 &miracast_plus_bt);
3458
3459 coex_dm->cur_algorithm = algorithm;
3460 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3461 "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
3462
3463 if (btc8821a2ant_is_common_action(btcoexist)) {
3464 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3465 "[BTCoex], Action 2-Ant common\n");
3466 coex_dm->auto_tdma_adjust = true;
3467 } else {
3468 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3469 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3470 "[BTCoex], pre_algorithm = %d, cur_algorithm = %d\n",
3471 coex_dm->pre_algorithm,
3472 coex_dm->cur_algorithm);
3473 coex_dm->auto_tdma_adjust = false;
3474 }
3475 switch (coex_dm->cur_algorithm) {
3476 case BT_8821A_2ANT_COEX_ALGO_SCO:
3477 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3478 "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3479 btc8821a2ant_action_sco(btcoexist);
3480 break;
3481 case BT_8821A_2ANT_COEX_ALGO_HID:
3482 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3483 "[BTCoex], Action 2-Ant, algorithm = HID\n");
3484 btc8821a2ant_action_hid(btcoexist);
3485 break;
3486 case BT_8821A_2ANT_COEX_ALGO_A2DP:
3487 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3488 "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3489 btc8821a2ant_action_a2dp(btcoexist);
3490 break;
3491 case BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS:
3492 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3493 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3494 btc8821a2ant_action_a2dp_pan_hs(btcoexist);
3495 break;
3496 case BT_8821A_2ANT_COEX_ALGO_PANEDR:
3497 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3498 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3499 btc8821a2ant_action_pan_edr(btcoexist);
3500 break;
3501 case BT_8821A_2ANT_COEX_ALGO_PANHS:
3502 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3503 "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3504 btc8821a2ant_action_pan_hs(btcoexist);
3505 break;
3506 case BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP:
3507 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3508 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3509 btc8821a2ant_action_pan_edr_a2dp(btcoexist);
3510 break;
3511 case BT_8821A_2ANT_COEX_ALGO_PANEDR_HID:
3512 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3513 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3514 btc8821a2ant_action_pan_edr_hid(btcoexist);
3515 break;
3516 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3517 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3518 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3519 btc8821a2ant_act_hid_a2dp_pan_edr(btcoexist);
3520 break;
3521 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP:
3522 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3523 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3524 btc8821a2ant_action_hid_a2dp(btcoexist);
3525 break;
3526 default:
3527 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3528 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3529 btc8821a2ant_coex_all_off(btcoexist);
3530 break;
3531 }
3532 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3533 }
3534 }
3535
3536 static void btc8821a2ant_wifi_off_hw_cfg(struct btc_coexist *btcoexist)
3537 {
3538 u8 h2c_parameter[2] = {0};
3539 u32 fw_ver = 0;
3540
3541 /* set wlan_act to low */
3542 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3543
3544 /* WiFi goto standby while GNT_BT 0-->1 */
3545 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
3546 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3547 if (fw_ver >= 0x180000) {
3548 /* Use H2C to set GNT_BT to HIGH */
3549 h2c_parameter[0] = 1;
3550 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
3551 } else {
3552 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
3553 }
3554 }
3555
3556 /**************************************************************
3557 * extern function start with ex_btc8821a2ant_
3558 **************************************************************/
3559 void ex_btc8821a2ant_init_hwconfig(struct btc_coexist *btcoexist)
3560 {
3561 struct rtl_priv *rtlpriv = btcoexist->adapter;
3562 u8 u1tmp = 0;
3563
3564 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3565 "[BTCoex], 2Ant Init HW Config!!\n");
3566
3567 /* backup rf 0x1e value */
3568 coex_dm->bt_rf0x1e_backup =
3569 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3570
3571 /* 0x790[5:0] = 0x5 */
3572 u1tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3573 u1tmp &= 0xc0;
3574 u1tmp |= 0x5;
3575 btcoexist->btc_write_1byte(btcoexist, 0x790, u1tmp);
3576
3577 /* Antenna config */
3578 btc8821a2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN, true, false);
3579 coex_sta->dis_ver_info_cnt = 0;
3580
3581 /* PTA parameter */
3582 btc8821a2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3583
3584 /* Enable counter statistics */
3585 /* 0x76e[3] = 1, WLAN_Act control by PTA */
3586 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3587 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3588 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3589 }
3590
3591 void ex_btc8821a2ant_pre_load_firmware(struct btc_coexist *btcoexist)
3592 {
3593 struct btc_board_info *board_info = &btcoexist->board_info;
3594 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
3595
3596 /**
3597 * S0 or S1 setting and Local register setting(By the setting fw can get
3598 * ant number, S0/S1, ... info)
3599 *
3600 * Local setting bit define
3601 * BIT0: "0" for no antenna inverse; "1" for antenna inverse
3602 * BIT1: "0" for internal switch; "1" for external switch
3603 * BIT2: "0" for one antenna; "1" for two antenna
3604 * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
3605 * BIT2=0
3606 */
3607 if (btcoexist->chip_interface == BTC_INTF_USB) {
3608 /* fixed at S0 for USB interface */
3609 u8tmp |= 0x1; /* antenna inverse */
3610 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3611 } else {
3612 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3613 if (board_info->single_ant_path == 0) {
3614 } else if (board_info->single_ant_path == 1) {
3615 /* set to S0 */
3616 u8tmp |= 0x1; /* antenna inverse */
3617 }
3618
3619 if (btcoexist->chip_interface == BTC_INTF_PCI)
3620 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
3621 u8tmp);
3622 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3623 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
3624 u8tmp);
3625 }
3626 }
3627
3628 void ex_btc8821a2ant_init_coex_dm(struct btc_coexist *btcoexist)
3629 {
3630 struct rtl_priv *rtlpriv = btcoexist->adapter;
3631
3632 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3633 "[BTCoex], Coex Mechanism Init!!\n");
3634
3635 btc8821a2ant_init_coex_dm(btcoexist);
3636 }
3637
3638 void ex_btc8821a2ant_display_coex_info(struct btc_coexist *btcoexist,
3639 struct seq_file *m)
3640 {
3641 struct btc_board_info *board_info = &btcoexist->board_info;
3642 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3643 u8 u1tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3644 u32 u4tmp[4];
3645 bool roam = false, scan = false, link = false, wifi_under_5g = false;
3646 bool bt_hs_on = false, wifi_busy = false;
3647 long wifi_rssi = 0, bt_hs_rssi = 0;
3648 u32 wifi_bw, wifi_traffic_dir;
3649 u8 wifi_dot_11_chnl, wifi_hs_chnl;
3650 u32 fw_ver = 0, bt_patch_ver = 0;
3651
3652 seq_puts(m, "\n ============[BT Coexist info]============");
3653
3654 seq_printf(m, "\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:",
3655 board_info->pg_ant_num, board_info->btdm_ant_num);
3656
3657 if (btcoexist->manual_control) {
3658 seq_printf(m, "\n %-35s", "[Action Manual control]!!");
3659 }
3660
3661 seq_printf(m, "\n %-35s = %s / %d", "BT stack/ hci ext ver",
3662 ((stack_info->profile_notified) ? "Yes" : "No"),
3663 stack_info->hci_version);
3664
3665 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3666 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3667 seq_printf(m, "\n %-35s = %d_%d/ 0x%x/ 0x%x(%d)",
3668 "CoexVer/ FwVer/ PatchVer",
3669 glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
3670 fw_ver, bt_patch_ver, bt_patch_ver);
3671
3672 btcoexist->btc_get(btcoexist,
3673 BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3674 btcoexist->btc_get(btcoexist,
3675 BTC_GET_U1_WIFI_DOT11_CHNL, &wifi_dot_11_chnl);
3676 btcoexist->btc_get(btcoexist,
3677 BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3678 seq_printf(m, "\n %-35s = %d / %d(%d)",
3679 "Dot11 channel / HsMode(HsChnl)",
3680 wifi_dot_11_chnl, bt_hs_on, wifi_hs_chnl);
3681
3682 seq_printf(m, "\n %-35s = %3ph ",
3683 "H2C Wifi inform bt chnl Info",
3684 coex_dm->wifi_chnl_info);
3685
3686 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3687 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3688 seq_printf(m, "\n %-35s = %ld/ %ld", "Wifi rssi/ HS rssi",
3689 wifi_rssi, bt_hs_rssi);
3690
3691 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3692 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3693 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3694 seq_printf(m, "\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
3695 link, roam, scan);
3696
3697 btcoexist->btc_get(btcoexist,
3698 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3699 btcoexist->btc_get(btcoexist,
3700 BTC_GET_U4_WIFI_BW, &wifi_bw);
3701 btcoexist->btc_get(btcoexist,
3702 BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3703 btcoexist->btc_get(btcoexist,
3704 BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifi_traffic_dir);
3705 seq_printf(m, "\n %-35s = %s / %s/ %s ", "Wifi status",
3706 (wifi_under_5g ? "5G" : "2.4G"),
3707 ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3708 (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3709 ((!wifi_busy) ? "idle" :
3710 ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3711 "uplink" : "downlink")));
3712
3713 if (stack_info->profile_notified) {
3714 seq_printf(m, "\n %-35s = %d / %d / %d / %d",
3715 "SCO/HID/PAN/A2DP",
3716 stack_info->sco_exist, stack_info->hid_exist,
3717 stack_info->pan_exist, stack_info->a2dp_exist);
3718
3719 btcoexist->btc_disp_dbg_msg(btcoexist,
3720 BTC_DBG_DISP_BT_LINK_INFO,
3721 m);
3722 }
3723
3724 bt_info_ext = coex_sta->bt_info_ext;
3725 seq_printf(m, "\n %-35s = %s", "BT Info A2DP rate",
3726 (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3727
3728 for (i = 0; i < BT_INFO_SRC_8821A_2ANT_MAX; i++) {
3729 if (coex_sta->bt_info_c2h_cnt[i]) {
3730 seq_printf(m, "\n %-35s = %7ph(%d)",
3731 glbt_info_src_8821a_2ant[i],
3732 coex_sta->bt_info_c2h[i],
3733 coex_sta->bt_info_c2h_cnt[i]);
3734 }
3735 }
3736
3737 seq_printf(m, "\n %-35s = %s/%s",
3738 "PS state, IPS/LPS",
3739 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3740 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3741 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
3742
3743 /* Sw mechanism*/
3744 seq_printf(m, "\n %-35s",
3745 "============[Sw mechanism]============");
3746 seq_printf(m, "\n %-35s = %d/ %d/ %d(0x%x) ",
3747 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3748 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3749 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3750
3751 /* Fw mechanism*/
3752 seq_printf(m, "\n %-35s",
3753 "============[Fw mechanism]============");
3754
3755 if (!btcoexist->manual_control) {
3756 ps_tdma_case = coex_dm->cur_ps_tdma;
3757 seq_printf(m, "\n %-35s = %5ph case-%d",
3758 "PS TDMA",
3759 coex_dm->ps_tdma_para, ps_tdma_case);
3760
3761 seq_printf(m, "\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct",
3762 coex_dm->cur_dec_bt_pwr_lvl,
3763 coex_dm->cur_ignore_wlan_act);
3764 }
3765
3766 /* Hw setting*/
3767 seq_printf(m, "\n %-35s", "============[Hw setting]============");
3768
3769 seq_printf(m, "\n %-35s = 0x%x", "RF-A, 0x1e initVal",
3770 coex_dm->bt_rf0x1e_backup);
3771
3772 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3773 u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3774 seq_printf(m, "\n %-35s = 0x%x/ 0x%x ",
3775 "0x778 (W_Act)/ 0x6cc (CoTab Sel)",
3776 u1tmp[0], u1tmp[1]);
3777
3778 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
3779 u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xc5b);
3780 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3781 "0x8db(ADC)/0xc5b[29:25](DAC)",
3782 ((u1tmp[0] & 0x60) >> 5), ((u1tmp[1] & 0x3e) >> 1));
3783
3784 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
3785 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3786 "0xcb4[7:0](ctrl)/ 0xcb4[29:28](val)",
3787 u4tmp[0] & 0xff, ((u4tmp[0] & 0x30000000) >> 28));
3788
3789 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3790 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3791 u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x974);
3792 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3793 "0x40/ 0x4c[24:23]/ 0x974",
3794 u1tmp[0], ((u4tmp[0] & 0x01800000) >> 23), u4tmp[1]);
3795
3796 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3797 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3798 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3799 "0x550(bcn ctrl)/0x522",
3800 u4tmp[0], u1tmp[0]);
3801
3802 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3803 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa0a);
3804 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3805 "0xc50(DIG)/0xa0a(CCK-TH)",
3806 u4tmp[0], u1tmp[0]);
3807
3808 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
3809 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3810 u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3811 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3812 "OFDM-FA/ CCK-FA",
3813 u4tmp[0], (u1tmp[0] << 8) + u1tmp[1]);
3814
3815 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3816 u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3817 u4tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3818 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3819 "0x6c0/0x6c4/0x6c8",
3820 u4tmp[0], u4tmp[1], u4tmp[2]);
3821
3822 seq_printf(m, "\n %-35s = %d/ %d",
3823 "0x770 (hi-pri Rx/Tx)",
3824 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3825 seq_printf(m, "\n %-35s = %d/ %d",
3826 "0x774(low-pri Rx/Tx)",
3827 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
3828
3829 /* Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang*/
3830 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x41b);
3831 seq_printf(m, "\n %-35s = 0x%x",
3832 "0x41b (mgntQ hang chk == 0xf)",
3833 u1tmp[0]);
3834
3835 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
3836 }
3837
3838 void ex_btc8821a2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3839 {
3840 struct rtl_priv *rtlpriv = btcoexist->adapter;
3841
3842 if (BTC_IPS_ENTER == type) {
3843 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3844 "[BTCoex], IPS ENTER notify\n");
3845 coex_sta->under_ips = true;
3846 btc8821a2ant_wifi_off_hw_cfg(btcoexist);
3847 btc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3848 btc8821a2ant_coex_all_off(btcoexist);
3849 } else if (BTC_IPS_LEAVE == type) {
3850 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3851 "[BTCoex], IPS LEAVE notify\n");
3852 coex_sta->under_ips = false;
3853 ex_btc8821a2ant_init_hwconfig(btcoexist);
3854 btc8821a2ant_init_coex_dm(btcoexist);
3855 btc8821a2ant_query_bt_info(btcoexist);
3856 }
3857 }
3858
3859 void ex_btc8821a2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3860 {
3861 struct rtl_priv *rtlpriv = btcoexist->adapter;
3862
3863 if (BTC_LPS_ENABLE == type) {
3864 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3865 "[BTCoex], LPS ENABLE notify\n");
3866 coex_sta->under_lps = true;
3867 } else if (BTC_LPS_DISABLE == type) {
3868 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3869 "[BTCoex], LPS DISABLE notify\n");
3870 coex_sta->under_lps = false;
3871 }
3872 }
3873
3874 void ex_btc8821a2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3875 {
3876 struct rtl_priv *rtlpriv = btcoexist->adapter;
3877
3878 if (BTC_SCAN_START == type) {
3879 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3880 "[BTCoex], SCAN START notify\n");
3881 } else if (BTC_SCAN_FINISH == type) {
3882 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3883 "[BTCoex], SCAN FINISH notify\n");
3884 }
3885 }
3886
3887 void ex_btc8821a2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3888 {
3889 struct rtl_priv *rtlpriv = btcoexist->adapter;
3890
3891 if (BTC_ASSOCIATE_START == type) {
3892 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3893 "[BTCoex], CONNECT START notify\n");
3894 } else if (BTC_ASSOCIATE_FINISH == type) {
3895 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3896 "[BTCoex], CONNECT FINISH notify\n");
3897 }
3898 }
3899
3900 void ex_btc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
3901 u8 type)
3902 {
3903 struct rtl_priv *rtlpriv = btcoexist->adapter;
3904 u8 h2c_parameter[3] = {0};
3905 u32 wifi_bw;
3906 u8 wifi_central_chnl;
3907 u8 ap_num = 0;
3908
3909 if (BTC_MEDIA_CONNECT == type) {
3910 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3911 "[BTCoex], MEDIA connect notify\n");
3912 } else {
3913 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3914 "[BTCoex], MEDIA disconnect notify\n");
3915 }
3916
3917 /* only 2.4G we need to inform bt the chnl mask */
3918 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
3919 &wifi_central_chnl);
3920 if ((BTC_MEDIA_CONNECT == type) &&
3921 (wifi_central_chnl <= 14)) {
3922 h2c_parameter[0] = 0x1;
3923 h2c_parameter[1] = wifi_central_chnl;
3924 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3925 if (wifi_bw == BTC_WIFI_BW_HT40) {
3926 h2c_parameter[2] = 0x30;
3927 } else {
3928 h2c_parameter[2] = 0x20;
3929 if (ap_num < 10)
3930 h2c_parameter[2] = 0x30;
3931 else
3932 h2c_parameter[2] = 0x20;
3933 }
3934 }
3935
3936 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3937 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3938 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3939
3940 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3941 "[BTCoex], FW write 0x66 = 0x%x\n",
3942 h2c_parameter[0] << 16 |
3943 h2c_parameter[1] << 8 |
3944 h2c_parameter[2]);
3945
3946 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3947 }
3948
3949 void ex_btc8821a2ant_special_packet_notify(struct btc_coexist *btcoexist,
3950 u8 type)
3951 {
3952 struct rtl_priv *rtlpriv = btcoexist->adapter;
3953
3954 if (type == BTC_PACKET_DHCP) {
3955 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3956 "[BTCoex], DHCP Packet notify\n");
3957 }
3958 }
3959
3960 void ex_btc8821a2ant_bt_info_notify(struct btc_coexist *btcoexist,
3961 u8 *tmp_buf, u8 length)
3962 {
3963 struct rtl_priv *rtlpriv = btcoexist->adapter;
3964 u8 bt_info = 0;
3965 u8 i, rsp_source = 0;
3966 bool bt_busy = false, limited_dig = false;
3967 bool wifi_connected = false, wifi_under_5g = false;
3968
3969 coex_sta->c2h_bt_info_req_sent = false;
3970 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3971 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3972 &wifi_connected);
3973
3974 rsp_source = tmp_buf[0] & 0xf;
3975 if (rsp_source >= BT_INFO_SRC_8821A_2ANT_MAX)
3976 rsp_source = BT_INFO_SRC_8821A_2ANT_WIFI_FW;
3977 coex_sta->bt_info_c2h_cnt[rsp_source]++;
3978
3979 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3980 "[BTCoex], Bt info[%d], length = %d, hex data = [",
3981 rsp_source, length);
3982 for (i = 0; i < length; i++) {
3983 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3984 if (i == 1)
3985 bt_info = tmp_buf[i];
3986 if (i == length - 1) {
3987 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3988 "0x%02x]\n", tmp_buf[i]);
3989 } else {
3990 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3991 "0x%02x, ", tmp_buf[i]);
3992 }
3993 }
3994
3995 if (btcoexist->manual_control) {
3996 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3997 "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
3998 return;
3999 }
4000
4001 if (BT_INFO_SRC_8821A_2ANT_WIFI_FW != rsp_source) {
4002 /* [3:0] */
4003 coex_sta->bt_retry_cnt =
4004 coex_sta->bt_info_c2h[rsp_source][2]&0xf;
4005
4006 coex_sta->bt_rssi =
4007 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4008
4009 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4010
4011 coex_sta->bt_tx_rx_mask =
4012 (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
4013 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
4014 &coex_sta->bt_tx_rx_mask);
4015 if (coex_sta->bt_tx_rx_mask) {
4016 /* BT into is responded by BT FW and BT RF REG 0x3C !=
4017 * 0x01 => Need to switch BT TRx Mask
4018 */
4019 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4020 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n");
4021 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
4022 0x3c, 0x01);
4023 }
4024
4025 /* Here we need to resend some wifi info to BT
4026 * because bt is reset and loss of the info
4027 */
4028 if ((coex_sta->bt_info_ext & BIT1)) {
4029 btcoexist->btc_get(btcoexist,
4030 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
4031 if (wifi_connected) {
4032 ex_btc8821a2ant_media_status_notify(btcoexist,
4033 BTC_MEDIA_CONNECT);
4034 } else {
4035 ex_btc8821a2ant_media_status_notify(btcoexist,
4036 BTC_MEDIA_DISCONNECT);
4037 }
4038
4039 }
4040
4041 if (!btcoexist->manual_control && !wifi_under_5g) {
4042 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4043 "[BTCoex], BT ext info = 0x%x!!\n",
4044 coex_sta->bt_info_ext);
4045 if ((coex_sta->bt_info_ext & BIT(3))) {
4046 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4047 "[BTCoex], BT ext info bit3=1, wifi_connected=%d\n",
4048 wifi_connected);
4049 if (wifi_connected) {
4050 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
4051 DBG_LOUD,
4052 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4053 btc8821a2ant_ignore_wlan_act(btcoexist,
4054 FORCE_EXEC,
4055 false);
4056 }
4057 } else {
4058 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4059 "[BTCoex], BT ext info bit3=0, wifi_connected=%d\n",
4060 wifi_connected);
4061 /* BT already NOT ignore Wlan active, do nothing
4062 * here.
4063 */
4064 if (!wifi_connected) {
4065 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
4066 DBG_LOUD,
4067 "[BTCoex], BT ext info bit3 check, set BT to ignore Wlan active!!\n");
4068 btc8821a2ant_ignore_wlan_act(
4069 btcoexist, FORCE_EXEC, true);
4070 }
4071 }
4072 }
4073 }
4074
4075 /* check BIT2 first ==> check if bt is under inquiry or page scan*/
4076 if (bt_info & BT_INFO_8821A_2ANT_B_INQ_PAGE) {
4077 coex_sta->c2h_bt_inquiry_page = true;
4078 } else {
4079 coex_sta->c2h_bt_inquiry_page = false;
4080 }
4081 /* set link exist status */
4082 if (!(bt_info & BT_INFO_8821A_2ANT_B_CONNECTION)) {
4083 coex_sta->bt_link_exist = false;
4084 coex_sta->pan_exist = false;
4085 coex_sta->a2dp_exist = false;
4086 coex_sta->hid_exist = false;
4087 coex_sta->sco_exist = false;
4088 } else { /* connection exists */
4089 coex_sta->bt_link_exist = true;
4090 if (bt_info & BT_INFO_8821A_2ANT_B_FTP)
4091 coex_sta->pan_exist = true;
4092 else
4093 coex_sta->pan_exist = false;
4094 if (bt_info & BT_INFO_8821A_2ANT_B_A2DP)
4095 coex_sta->a2dp_exist = true;
4096 else
4097 coex_sta->a2dp_exist = false;
4098 if (bt_info & BT_INFO_8821A_2ANT_B_HID)
4099 coex_sta->hid_exist = true;
4100 else
4101 coex_sta->hid_exist = false;
4102 if (bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO)
4103 coex_sta->sco_exist = true;
4104 else
4105 coex_sta->sco_exist = false;
4106
4107 if ((!coex_sta->hid_exist) &&
4108 (!coex_sta->c2h_bt_inquiry_page) &&
4109 (!coex_sta->sco_exist)) {
4110 if (coex_sta->high_priority_tx +
4111 coex_sta->high_priority_rx >= 160)
4112 coex_sta->hid_exist = true;
4113 }
4114 }
4115
4116 btc8821a2ant_update_bt_link_info(btcoexist);
4117
4118 if (!(bt_info & BT_INFO_8821A_2ANT_B_CONNECTION)) {
4119 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_IDLE;
4120 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4121 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4122 } else if (bt_info == BT_INFO_8821A_2ANT_B_CONNECTION) {
4123 /* connection exists but no busy */
4124 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_CON_IDLE;
4125 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4126 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4127 } else if ((bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO) ||
4128 (bt_info & BT_INFO_8821A_2ANT_B_SCO_BUSY)) {
4129 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_SCO_BUSY;
4130 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4131 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4132 } else if (bt_info & BT_INFO_8821A_2ANT_B_ACL_BUSY) {
4133 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_ACL_BUSY;
4134 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4135 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4136 } else {
4137 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_MAX;
4138 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4139 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4140 }
4141
4142 if ((coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_ACL_BUSY) ||
4143 (coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_SCO_BUSY) ||
4144 (coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_ACL_SCO_BUSY)) {
4145 bt_busy = true;
4146 limited_dig = true;
4147 } else {
4148 bt_busy = false;
4149 limited_dig = false;
4150 }
4151
4152 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4153
4154 coex_dm->limited_dig = limited_dig;
4155 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4156
4157 btc8821a2ant_run_coexist_mechanism(btcoexist);
4158 }
4159
4160 void ex_btc8821a2ant_halt_notify(struct btc_coexist *btcoexist)
4161 {
4162 struct rtl_priv *rtlpriv = btcoexist->adapter;
4163
4164 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4165 "[BTCoex], Halt notify\n");
4166
4167 btc8821a2ant_wifi_off_hw_cfg(btcoexist);
4168 btc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4169 ex_btc8821a2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4170 }
4171
4172 void ex_btc8821a2ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
4173 {
4174 struct rtl_priv *rtlpriv = btcoexist->adapter;
4175
4176 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
4177
4178 if (pnp_state == BTC_WIFI_PNP_SLEEP) {
4179 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4180 "[BTCoex], Pnp notify to SLEEP\n");
4181 } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
4182 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4183 "[BTCoex], Pnp notify to WAKE UP\n");
4184 ex_btc8821a2ant_init_hwconfig(btcoexist);
4185 btc8821a2ant_init_coex_dm(btcoexist);
4186 btc8821a2ant_query_bt_info(btcoexist);
4187 }
4188 }
4189
4190 void ex_btc8821a2ant_periodical(struct btc_coexist *btcoexist)
4191 {
4192 struct rtl_priv *rtlpriv = btcoexist->adapter;
4193
4194 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4195 "[BTCoex], ==========================Periodical===========================\n");
4196
4197 if (coex_sta->dis_ver_info_cnt <= 5) {
4198 coex_sta->dis_ver_info_cnt += 1;
4199 if (coex_sta->dis_ver_info_cnt == 3) {
4200 /* Antenna config to set 0x765 = 0x0 (GNT_BT control by
4201 * PTA) after initial
4202 */
4203 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4204 "[BTCoex], Set GNT_BT control by PTA\n");
4205 btc8821a2ant_set_ant_path(btcoexist,
4206 BTC_ANT_WIFI_AT_MAIN, false, false);
4207 }
4208 }
4209
4210 if (btcoexist->auto_report_2ant) {
4211 btc8821a2ant_query_bt_info(btcoexist);
4212 } else {
4213 btc8821a2ant_monitor_bt_ctr(btcoexist);
4214 btc8821a2ant_monitor_wifi_ctr(btcoexist);
4215
4216 if (btc8821a2ant_is_wifi_status_changed(btcoexist) ||
4217 coex_dm->auto_tdma_adjust)
4218 btc8821a2ant_run_coexist_mechanism(btcoexist);
4219 }
4220 }
Linux with added FPC-III support