?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / net / wireless / realtek / rtlwifi / btcoexist / halbtc8821a2ant.c
blob447caa4aad325bfcfc4978c707f1915e0b608f87
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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(rtlpriv, COMP_BT_COEXIST,
471 DBG_LOUD,
472 "[BTCoex], PAN(HS) only\n");
473 algorithm = BT_8821A_2ANT_COEX_ALGO_PANHS;
474 } else {
475 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(rtlpriv, COMP_BT_COEXIST,
495 DBG_LOUD,
496 "[BTCoex], SCO + PAN(HS)\n");
497 algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
498 } else {
499 rtl_dbg(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 rtl_dbg(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 rtl_dbg(rtlpriv, COMP_BT_COEXIST,
515 DBG_LOUD,
516 "[BTCoex], HID + PAN(HS)\n");
517 algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
518 } else {
519 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(rtlpriv, COMP_BT_COEXIST,
602 DBG_LOUD,
603 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
604
605 } else {
606 rtl_dbg(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 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
629 "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swing_lvl);
630 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 rtl_dbg(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 bool wifi_connected = false;
1452 bool low_pwr_disable = true;
1453 bool scan = false, link = false, roam = false;
1454
1455 btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1456 btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1457 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
1458 btc8821a2ant_bt_rssi_state(btcoexist,
1459 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1460
1461 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1462 &low_pwr_disable);
1463 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1464 &wifi_connected);
1465
1466 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1467 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1468 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1469
1470 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1471
1472 if (scan || link || roam) {
1473 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1474 "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1475 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1476 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1477 } else if (wifi_connected) {
1478 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1479 "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1480 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1481 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1482 } else {
1483 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1484 "[BTCoex], Wifi no-link + BT Inq/Page!!\n");
1485 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1486 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1487 }
1488
1489 btc8821a2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1490 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1491
1492 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1493 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1494 }
1495
1496 static void btc8821a2ant_action_wifi_link_process(struct btc_coexist *btcoexist)
1497 {
1498 struct rtl_priv *rtlpriv = btcoexist->adapter;
1499 u8 u8tmpa, u8tmpb;
1500
1501 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1502 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1503
1504 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
1505 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1506
1507 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1508 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1509
1510 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1511 "[BTCoex], 0x765=0x%x, 0x76e=0x%x\n", u8tmpa, u8tmpb);
1512 }
1513
1514 static bool btc8821a2ant_action_wifi_idle_process(struct btc_coexist *btcoexist)
1515 {
1516 struct rtl_priv *rtlpriv = btcoexist->adapter;
1517 u8 wifi_rssi_state1;
1518 u8 ap_num = 0;
1519
1520 btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1521 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
1522 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES - 20, 0);
1523 btc8821a2ant_bt_rssi_state(btcoexist,
1524 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
1525
1526 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1527
1528 /* define the office environment */
1529 if (BTC_RSSI_HIGH(wifi_rssi_state1) && (coex_sta->hid_exist) &&
1530 (coex_sta->a2dp_exist)) {
1531 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1532 "[BTCoex], Wifi idle process for BT HID+A2DP exist!!\n");
1533
1534 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1535 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1536
1537 /* sw all off */
1538 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1539 false);
1540 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1541 0x18);
1542
1543 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1544 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1545 0x0, 0x0);
1546 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1547
1548 return true;
1549 } else if (coex_sta->pan_exist) {
1550 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1551 "[BTCoex], Wifi idle process for BT PAN exist!!\n");
1552
1553 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1554 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1555
1556 /* sw all off */
1557 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1558 false);
1559 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1560 0x18);
1561
1562 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1563 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1564 0x0, 0x0);
1565 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1566
1567 return true;
1568 }
1569 btc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1570 return false;
1571 }
1572
1573 static bool btc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
1574 {
1575 struct rtl_priv *rtlpriv = btcoexist->adapter;
1576 bool common = false, wifi_connected = false, wifi_busy = false;
1577 bool low_pwr_disable = false;
1578 bool bt_hs_on = false;
1579
1580 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1581 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1582 &wifi_connected);
1583 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1584
1585 if (!wifi_connected) {
1586 low_pwr_disable = false;
1587 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1588 &low_pwr_disable);
1589 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
1590 0x8);
1591
1592 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1593 "[BTCoex], Wifi non-connected idle!!\n");
1594
1595 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1596 0x0);
1597 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1598 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1599 0x0, 0x0);
1600 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1601 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1602 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1603
1604 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false,
1605 false);
1606 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false,
1607 0x18);
1608
1609 common = true;
1610 } else {
1611 if (BT_8821A_2ANT_BT_STATUS_IDLE ==
1612 coex_dm->bt_status) {
1613 low_pwr_disable = false;
1614 btcoexist->btc_set(btcoexist,
1615 BTC_SET_ACT_DISABLE_LOW_POWER,
1616 &low_pwr_disable);
1617 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC,
1618 false, false, 0x8);
1619
1620 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1621 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1622
1623 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1624 0xfffff, 0x0);
1625 btc8821a2ant_coex_table_with_type(btcoexist,
1626 NORMAL_EXEC, 0);
1627
1628 btc8821a2ant_power_save_state(
1629 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1630 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1631 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1632 0xb);
1633 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1634
1635 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
1636 false, false);
1637 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
1638 false, 0x18);
1639
1640 common = true;
1641 } else if (BT_8821A_2ANT_BT_STATUS_CON_IDLE ==
1642 coex_dm->bt_status) {
1643 low_pwr_disable = true;
1644 btcoexist->btc_set(btcoexist,
1645 BTC_SET_ACT_DISABLE_LOW_POWER,
1646 &low_pwr_disable);
1647
1648 if (bt_hs_on)
1649 return false;
1650 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1651 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1652 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC,
1653 false, false, 0x8);
1654
1655 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1656 0xfffff, 0x0);
1657 btc8821a2ant_coex_table_with_type(btcoexist,
1658 NORMAL_EXEC, 0);
1659
1660 btc8821a2ant_power_save_state(
1661 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1662 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1663 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1664 0xb);
1665 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1666
1667 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
1668 false, false);
1669 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
1670 false, 0x18);
1671 common = true;
1672 } else {
1673 low_pwr_disable = true;
1674 btcoexist->btc_set(btcoexist,
1675 BTC_SET_ACT_DISABLE_LOW_POWER,
1676 &low_pwr_disable);
1677
1678 if (wifi_busy) {
1679 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1680 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1681 common = false;
1682 } else {
1683 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1684 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1685 common =
1686 btc8821a2ant_action_wifi_idle_process(
1687 btcoexist);
1688 }
1689 }
1690 }
1691 return common;
1692 }
1693
1694 static void btc8821a2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
1695 bool sco_hid, bool tx_pause,
1696 u8 max_interval)
1697 {
1698 struct rtl_priv *rtlpriv = btcoexist->adapter;
1699 static long up, dn, m, n, wait_count;
1700 /* 0 : no change
1701 * +1: increase WiFi duration
1702 * -1: decrease WiFi duration
1703 */
1704 int result;
1705 u8 retry_count = 0;
1706
1707 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1708 "[BTCoex], TdmaDurationAdjust()\n");
1709
1710 if (coex_dm->auto_tdma_adjust) {
1711 coex_dm->auto_tdma_adjust = false;
1712 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1713 "[BTCoex], first run TdmaDurationAdjust()!!\n");
1714 if (sco_hid) {
1715 if (tx_pause) {
1716 if (max_interval == 1) {
1717 btc8821a2ant_ps_tdma(btcoexist,
1718 NORMAL_EXEC, true, 13);
1719 coex_dm->ps_tdma_du_adj_type = 13;
1720 } else if (max_interval == 2) {
1721 btc8821a2ant_ps_tdma(btcoexist,
1722 NORMAL_EXEC, true, 14);
1723 coex_dm->ps_tdma_du_adj_type = 14;
1724 } else if (max_interval == 3) {
1725 btc8821a2ant_ps_tdma(btcoexist,
1726 NORMAL_EXEC, true, 15);
1727 coex_dm->ps_tdma_du_adj_type = 15;
1728 } else {
1729 btc8821a2ant_ps_tdma(btcoexist,
1730 NORMAL_EXEC, true, 15);
1731 coex_dm->ps_tdma_du_adj_type = 15;
1732 }
1733 } else {
1734 if (max_interval == 1) {
1735 btc8821a2ant_ps_tdma(btcoexist,
1736 NORMAL_EXEC, true, 9);
1737 coex_dm->ps_tdma_du_adj_type = 9;
1738 } else if (max_interval == 2) {
1739 btc8821a2ant_ps_tdma(btcoexist,
1740 NORMAL_EXEC, true, 10);
1741 coex_dm->ps_tdma_du_adj_type = 10;
1742 } else if (max_interval == 3) {
1743 btc8821a2ant_ps_tdma(btcoexist,
1744 NORMAL_EXEC, true, 11);
1745 coex_dm->ps_tdma_du_adj_type = 11;
1746 } else {
1747 btc8821a2ant_ps_tdma(btcoexist,
1748 NORMAL_EXEC, true, 11);
1749 coex_dm->ps_tdma_du_adj_type = 11;
1750 }
1751 }
1752 } else {
1753 if (tx_pause) {
1754 if (max_interval == 1) {
1755 btc8821a2ant_ps_tdma(btcoexist,
1756 NORMAL_EXEC, true, 5);
1757 coex_dm->ps_tdma_du_adj_type = 5;
1758 } else if (max_interval == 2) {
1759 btc8821a2ant_ps_tdma(btcoexist,
1760 NORMAL_EXEC, true, 6);
1761 coex_dm->ps_tdma_du_adj_type = 6;
1762 } else if (max_interval == 3) {
1763 btc8821a2ant_ps_tdma(btcoexist,
1764 NORMAL_EXEC, true, 7);
1765 coex_dm->ps_tdma_du_adj_type = 7;
1766 } else {
1767 btc8821a2ant_ps_tdma(btcoexist,
1768 NORMAL_EXEC, true, 7);
1769 coex_dm->ps_tdma_du_adj_type = 7;
1770 }
1771 } else {
1772 if (max_interval == 1) {
1773 btc8821a2ant_ps_tdma(btcoexist,
1774 NORMAL_EXEC, true, 1);
1775 coex_dm->ps_tdma_du_adj_type = 1;
1776 } else if (max_interval == 2) {
1777 btc8821a2ant_ps_tdma(btcoexist,
1778 NORMAL_EXEC, true, 2);
1779 coex_dm->ps_tdma_du_adj_type = 2;
1780 } else if (max_interval == 3) {
1781 btc8821a2ant_ps_tdma(btcoexist,
1782 NORMAL_EXEC, true, 3);
1783 coex_dm->ps_tdma_du_adj_type = 3;
1784 } else {
1785 btc8821a2ant_ps_tdma(btcoexist,
1786 NORMAL_EXEC, true, 3);
1787 coex_dm->ps_tdma_du_adj_type = 3;
1788 }
1789 }
1790 }
1791
1792 up = 0;
1793 dn = 0;
1794 m = 1;
1795 n = 3;
1796 result = 0;
1797 wait_count = 0;
1798 } else {
1799 /* accquire the BT TRx retry count from BT_Info byte2 */
1800 retry_count = coex_sta->bt_retry_cnt;
1801 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1802 "[BTCoex], retry_count = %d\n", retry_count);
1803 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1804 "[BTCoex], up = %d, dn = %d, m = %d, n = %d, wait_count = %d\n",
1805 (int)up, (int)dn, (int)m, (int)n, (int)wait_count);
1806 result = 0;
1807 wait_count++;
1808
1809 if (retry_count == 0) {
1810 /* no retry in the last 2-second duration */
1811 up++;
1812 dn--;
1813
1814 if (dn <= 0)
1815 dn = 0;
1816
1817 if (up >= n) {
1818 /* if (retry count == 0) for 2*n seconds,
1819 * make WiFi duration wider
1820 */
1821 wait_count = 0;
1822 n = 3;
1823 up = 0;
1824 dn = 0;
1825 result = 1;
1826 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1827 "[BTCoex], Increase wifi duration!!\n");
1828 }
1829 } else if (retry_count <= 3) {
1830 /* <=3 retry in the last 2-second duration */
1831 up--;
1832 dn++;
1833
1834 if (up <= 0)
1835 up = 0;
1836
1837 if (dn == 2) {
1838 /* if retry count < 3 for 2*2 seconds,
1839 * shrink wifi duration
1840 */
1841 if (wait_count <= 2)
1842 m++; /* avoid bounce in two levels */
1843 else
1844 m = 1;
1845 /* m max value is 20, max time is 120 second,
1846 * recheck if adjust WiFi duration.
1847 */
1848 if (m >= 20)
1849 m = 20;
1850
1851 n = 3 * m;
1852 up = 0;
1853 dn = 0;
1854 wait_count = 0;
1855 result = -1;
1856 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1857 "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1858 }
1859 } else {
1860 /* retry count > 3, if retry count > 3 happens once,
1861 * shrink WiFi duration
1862 */
1863 if (wait_count == 1)
1864 m++; /* avoid bounce in two levels */
1865 else
1866 m = 1;
1867 /* m max value is 20, max time is 120 second,
1868 * recheck if adjust WiFi duration.
1869 */
1870 if (m >= 20)
1871 m = 20;
1872
1873 n = 3 * m;
1874 up = 0;
1875 dn = 0;
1876 wait_count = 0;
1877 result = -1;
1878 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1879 "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1880 }
1881
1882 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1883 "[BTCoex], max Interval = %d\n", max_interval);
1884
1885 if (max_interval == 1) {
1886 if (tx_pause) {
1887 if (coex_dm->cur_ps_tdma == 71) {
1888 btc8821a2ant_ps_tdma(btcoexist,
1889 NORMAL_EXEC, true, 5);
1890 coex_dm->ps_tdma_du_adj_type = 5;
1891 } else if (coex_dm->cur_ps_tdma == 1) {
1892 btc8821a2ant_ps_tdma(btcoexist,
1893 NORMAL_EXEC, true, 5);
1894 coex_dm->ps_tdma_du_adj_type = 5;
1895 } else if (coex_dm->cur_ps_tdma == 2) {
1896 btc8821a2ant_ps_tdma(btcoexist,
1897 NORMAL_EXEC, true, 6);
1898 coex_dm->ps_tdma_du_adj_type = 6;
1899 } else if (coex_dm->cur_ps_tdma == 3) {
1900 btc8821a2ant_ps_tdma(btcoexist,
1901 NORMAL_EXEC, true, 7);
1902 coex_dm->ps_tdma_du_adj_type = 7;
1903 } else if (coex_dm->cur_ps_tdma == 4) {
1904 btc8821a2ant_ps_tdma(btcoexist,
1905 NORMAL_EXEC, true, 8);
1906 coex_dm->ps_tdma_du_adj_type = 8;
1907 }
1908 if (coex_dm->cur_ps_tdma == 9) {
1909 btc8821a2ant_ps_tdma(btcoexist,
1910 NORMAL_EXEC, true, 13);
1911 coex_dm->ps_tdma_du_adj_type = 13;
1912 } else if (coex_dm->cur_ps_tdma == 10) {
1913 btc8821a2ant_ps_tdma(btcoexist,
1914 NORMAL_EXEC, true, 14);
1915 coex_dm->ps_tdma_du_adj_type = 14;
1916 } else if (coex_dm->cur_ps_tdma == 11) {
1917 btc8821a2ant_ps_tdma(btcoexist,
1918 NORMAL_EXEC, true, 15);
1919 coex_dm->ps_tdma_du_adj_type = 15;
1920 } else if (coex_dm->cur_ps_tdma == 12) {
1921 btc8821a2ant_ps_tdma(btcoexist,
1922 NORMAL_EXEC, true, 16);
1923 coex_dm->ps_tdma_du_adj_type = 16;
1924 }
1925
1926 if (result == -1) {
1927 if (coex_dm->cur_ps_tdma == 5) {
1928 btc8821a2ant_ps_tdma(
1929 btcoexist, NORMAL_EXEC,
1930 true, 6);
1931 coex_dm->ps_tdma_du_adj_type =
1932 6;
1933 } else if (coex_dm->cur_ps_tdma == 6) {
1934 btc8821a2ant_ps_tdma(
1935 btcoexist, NORMAL_EXEC,
1936 true, 7);
1937 coex_dm->ps_tdma_du_adj_type =
1938 7;
1939 } else if (coex_dm->cur_ps_tdma == 7) {
1940 btc8821a2ant_ps_tdma(
1941 btcoexist, NORMAL_EXEC,
1942 true, 8);
1943 coex_dm->ps_tdma_du_adj_type =
1944 8;
1945 } else if (coex_dm->cur_ps_tdma == 13) {
1946 btc8821a2ant_ps_tdma(
1947 btcoexist, NORMAL_EXEC,
1948 true, 14);
1949 coex_dm->ps_tdma_du_adj_type =
1950 14;
1951 } else if (coex_dm->cur_ps_tdma == 14) {
1952 btc8821a2ant_ps_tdma(
1953 btcoexist, NORMAL_EXEC,
1954 true, 15);
1955 coex_dm->ps_tdma_du_adj_type =
1956 15;
1957 } else if (coex_dm->cur_ps_tdma == 15) {
1958 btc8821a2ant_ps_tdma(
1959 btcoexist, NORMAL_EXEC,
1960 true, 16);
1961 coex_dm->ps_tdma_du_adj_type =
1962 16;
1963 }
1964 } else if (result == 1) {
1965 if (coex_dm->cur_ps_tdma == 8) {
1966 btc8821a2ant_ps_tdma(
1967 btcoexist, NORMAL_EXEC,
1968 true, 7);
1969 coex_dm->ps_tdma_du_adj_type =
1970 7;
1971 } else if (coex_dm->cur_ps_tdma == 7) {
1972 btc8821a2ant_ps_tdma(
1973 btcoexist, NORMAL_EXEC,
1974 true, 6);
1975 coex_dm->ps_tdma_du_adj_type =
1976 6;
1977 } else if (coex_dm->cur_ps_tdma == 6) {
1978 btc8821a2ant_ps_tdma(
1979 btcoexist, NORMAL_EXEC,
1980 true, 5);
1981 coex_dm->ps_tdma_du_adj_type =
1982 5;
1983 } else if (coex_dm->cur_ps_tdma == 16) {
1984 btc8821a2ant_ps_tdma(
1985 btcoexist, NORMAL_EXEC,
1986 true, 15);
1987 coex_dm->ps_tdma_du_adj_type =
1988 15;
1989 } else if (coex_dm->cur_ps_tdma == 15) {
1990 btc8821a2ant_ps_tdma(
1991 btcoexist, NORMAL_EXEC,
1992 true, 14);
1993 coex_dm->ps_tdma_du_adj_type =
1994 14;
1995 } else if (coex_dm->cur_ps_tdma == 14) {
1996 btc8821a2ant_ps_tdma(
1997 btcoexist, NORMAL_EXEC,
1998 true, 13);
1999 coex_dm->ps_tdma_du_adj_type =
2000 13;
2001 }
2002 }
2003 } else {
2004 if (coex_dm->cur_ps_tdma == 5) {
2005 btc8821a2ant_ps_tdma(btcoexist,
2006 NORMAL_EXEC, true, 71);
2007 coex_dm->ps_tdma_du_adj_type = 71;
2008 } else if (coex_dm->cur_ps_tdma == 6) {
2009 btc8821a2ant_ps_tdma(btcoexist,
2010 NORMAL_EXEC, true, 2);
2011 coex_dm->ps_tdma_du_adj_type = 2;
2012 } else if (coex_dm->cur_ps_tdma == 7) {
2013 btc8821a2ant_ps_tdma(btcoexist,
2014 NORMAL_EXEC, true, 3);
2015 coex_dm->ps_tdma_du_adj_type = 3;
2016 } else if (coex_dm->cur_ps_tdma == 8) {
2017 btc8821a2ant_ps_tdma(btcoexist,
2018 NORMAL_EXEC, true, 4);
2019 coex_dm->ps_tdma_du_adj_type = 4;
2020 }
2021 if (coex_dm->cur_ps_tdma == 13) {
2022 btc8821a2ant_ps_tdma(btcoexist,
2023 NORMAL_EXEC, true, 9);
2024 coex_dm->ps_tdma_du_adj_type = 9;
2025 } else if (coex_dm->cur_ps_tdma == 14) {
2026 btc8821a2ant_ps_tdma(btcoexist,
2027 NORMAL_EXEC, true, 10);
2028 coex_dm->ps_tdma_du_adj_type = 10;
2029 } else if (coex_dm->cur_ps_tdma == 15) {
2030 btc8821a2ant_ps_tdma(btcoexist,
2031 NORMAL_EXEC, true, 11);
2032 coex_dm->ps_tdma_du_adj_type = 11;
2033 } else if (coex_dm->cur_ps_tdma == 16) {
2034 btc8821a2ant_ps_tdma(btcoexist,
2035 NORMAL_EXEC, true, 12);
2036 coex_dm->ps_tdma_du_adj_type = 12;
2037 }
2038
2039 if (result == -1) {
2040 if (coex_dm->cur_ps_tdma == 71) {
2041 btc8821a2ant_ps_tdma(
2042 btcoexist, NORMAL_EXEC,
2043 true, 1);
2044 coex_dm->ps_tdma_du_adj_type =
2045 1;
2046 } else if (coex_dm->cur_ps_tdma == 1) {
2047 btc8821a2ant_ps_tdma(
2048 btcoexist, NORMAL_EXEC,
2049 true, 2);
2050 coex_dm->ps_tdma_du_adj_type =
2051 2;
2052 } else if (coex_dm->cur_ps_tdma == 2) {
2053 btc8821a2ant_ps_tdma(
2054 btcoexist, NORMAL_EXEC,
2055 true, 3);
2056 coex_dm->ps_tdma_du_adj_type =
2057 3;
2058 } else if (coex_dm->cur_ps_tdma == 3) {
2059 btc8821a2ant_ps_tdma(
2060 btcoexist, NORMAL_EXEC,
2061 true, 4);
2062 coex_dm->ps_tdma_du_adj_type =
2063 4;
2064 } else if (coex_dm->cur_ps_tdma == 9) {
2065 btc8821a2ant_ps_tdma(
2066 btcoexist, NORMAL_EXEC,
2067 true, 10);
2068 coex_dm->ps_tdma_du_adj_type =
2069 10;
2070 } else if (coex_dm->cur_ps_tdma == 10) {
2071 btc8821a2ant_ps_tdma(
2072 btcoexist, NORMAL_EXEC,
2073 true, 11);
2074 coex_dm->ps_tdma_du_adj_type =
2075 11;
2076 } else if (coex_dm->cur_ps_tdma == 11) {
2077 btc8821a2ant_ps_tdma(
2078 btcoexist, NORMAL_EXEC,
2079 true, 12);
2080 coex_dm->ps_tdma_du_adj_type =
2081 12;
2082 }
2083 } else if (result == 1) {
2084 if (coex_dm->cur_ps_tdma == 4) {
2085 btc8821a2ant_ps_tdma(
2086 btcoexist, NORMAL_EXEC,
2087 true, 3);
2088 coex_dm->ps_tdma_du_adj_type =
2089 3;
2090 } else if (coex_dm->cur_ps_tdma == 3) {
2091 btc8821a2ant_ps_tdma(
2092 btcoexist, NORMAL_EXEC,
2093 true, 2);
2094 coex_dm->ps_tdma_du_adj_type =
2095 2;
2096 } else if (coex_dm->cur_ps_tdma == 2) {
2097 btc8821a2ant_ps_tdma(
2098 btcoexist, NORMAL_EXEC,
2099 true, 1);
2100 coex_dm->ps_tdma_du_adj_type =
2101 1;
2102 } else if (coex_dm->cur_ps_tdma == 1) {
2103 btc8821a2ant_ps_tdma(
2104 btcoexist, NORMAL_EXEC,
2105 true, 71);
2106 coex_dm->ps_tdma_du_adj_type =
2107 71;
2108 } else if (coex_dm->cur_ps_tdma == 12) {
2109 btc8821a2ant_ps_tdma(
2110 btcoexist, NORMAL_EXEC,
2111 true, 11);
2112 coex_dm->ps_tdma_du_adj_type =
2113 11;
2114 } else if (coex_dm->cur_ps_tdma == 11) {
2115 btc8821a2ant_ps_tdma(
2116 btcoexist, NORMAL_EXEC,
2117 true, 10);
2118 coex_dm->ps_tdma_du_adj_type =
2119 10;
2120 } else if (coex_dm->cur_ps_tdma == 10) {
2121 btc8821a2ant_ps_tdma(
2122 btcoexist, NORMAL_EXEC,
2123 true, 9);
2124 coex_dm->ps_tdma_du_adj_type =
2125 9;
2126 }
2127 }
2128 }
2129 } else if (max_interval == 2) {
2130 if (tx_pause) {
2131 if (coex_dm->cur_ps_tdma == 1) {
2132 btc8821a2ant_ps_tdma(btcoexist,
2133 NORMAL_EXEC, true, 6);
2134 coex_dm->ps_tdma_du_adj_type = 6;
2135 } else if (coex_dm->cur_ps_tdma == 2) {
2136 btc8821a2ant_ps_tdma(btcoexist,
2137 NORMAL_EXEC, true, 6);
2138 coex_dm->ps_tdma_du_adj_type = 6;
2139 } else if (coex_dm->cur_ps_tdma == 3) {
2140 btc8821a2ant_ps_tdma(btcoexist,
2141 NORMAL_EXEC, true, 7);
2142 coex_dm->ps_tdma_du_adj_type = 7;
2143 } else if (coex_dm->cur_ps_tdma == 4) {
2144 btc8821a2ant_ps_tdma(btcoexist,
2145 NORMAL_EXEC, true, 8);
2146 coex_dm->ps_tdma_du_adj_type = 8;
2147 }
2148 if (coex_dm->cur_ps_tdma == 9) {
2149 btc8821a2ant_ps_tdma(btcoexist,
2150 NORMAL_EXEC, true, 14);
2151 coex_dm->ps_tdma_du_adj_type = 14;
2152 } else if (coex_dm->cur_ps_tdma == 10) {
2153 btc8821a2ant_ps_tdma(btcoexist,
2154 NORMAL_EXEC, true, 14);
2155 coex_dm->ps_tdma_du_adj_type = 14;
2156 } else if (coex_dm->cur_ps_tdma == 11) {
2157 btc8821a2ant_ps_tdma(btcoexist,
2158 NORMAL_EXEC, true, 15);
2159 coex_dm->ps_tdma_du_adj_type = 15;
2160 } else if (coex_dm->cur_ps_tdma == 12) {
2161 btc8821a2ant_ps_tdma(btcoexist,
2162 NORMAL_EXEC, true, 16);
2163 coex_dm->ps_tdma_du_adj_type = 16;
2164 }
2165 if (result == -1) {
2166 if (coex_dm->cur_ps_tdma == 5) {
2167 btc8821a2ant_ps_tdma(
2168 btcoexist, NORMAL_EXEC,
2169 true, 6);
2170 coex_dm->ps_tdma_du_adj_type =
2171 6;
2172 } else if (coex_dm->cur_ps_tdma == 6) {
2173 btc8821a2ant_ps_tdma(
2174 btcoexist, NORMAL_EXEC,
2175 true, 7);
2176 coex_dm->ps_tdma_du_adj_type =
2177 7;
2178 } else if (coex_dm->cur_ps_tdma == 7) {
2179 btc8821a2ant_ps_tdma(
2180 btcoexist, NORMAL_EXEC,
2181 true, 8);
2182 coex_dm->ps_tdma_du_adj_type =
2183 8;
2184 } else if (coex_dm->cur_ps_tdma == 13) {
2185 btc8821a2ant_ps_tdma(
2186 btcoexist, NORMAL_EXEC,
2187 true, 14);
2188 coex_dm->ps_tdma_du_adj_type =
2189 14;
2190 } else if (coex_dm->cur_ps_tdma == 14) {
2191 btc8821a2ant_ps_tdma(
2192 btcoexist, NORMAL_EXEC,
2193 true, 15);
2194 coex_dm->ps_tdma_du_adj_type =
2195 15;
2196 } else if (coex_dm->cur_ps_tdma == 15) {
2197 btc8821a2ant_ps_tdma(
2198 btcoexist, NORMAL_EXEC,
2199 true, 16);
2200 coex_dm->ps_tdma_du_adj_type =
2201 16;
2202 }
2203 } else if (result == 1) {
2204 if (coex_dm->cur_ps_tdma == 8) {
2205 btc8821a2ant_ps_tdma(
2206 btcoexist, NORMAL_EXEC,
2207 true, 7);
2208 coex_dm->ps_tdma_du_adj_type =
2209 7;
2210 } else if (coex_dm->cur_ps_tdma == 7) {
2211 btc8821a2ant_ps_tdma(
2212 btcoexist, NORMAL_EXEC,
2213 true, 6);
2214 coex_dm->ps_tdma_du_adj_type =
2215 6;
2216 } else if (coex_dm->cur_ps_tdma == 6) {
2217 btc8821a2ant_ps_tdma(
2218 btcoexist, NORMAL_EXEC,
2219 true, 6);
2220 coex_dm->ps_tdma_du_adj_type =
2221 6;
2222 } else if (coex_dm->cur_ps_tdma == 16) {
2223 btc8821a2ant_ps_tdma(
2224 btcoexist, NORMAL_EXEC,
2225 true, 15);
2226 coex_dm->ps_tdma_du_adj_type =
2227 15;
2228 } else if (coex_dm->cur_ps_tdma == 15) {
2229 btc8821a2ant_ps_tdma(
2230 btcoexist, NORMAL_EXEC,
2231 true, 14);
2232 coex_dm->ps_tdma_du_adj_type =
2233 14;
2234 } else if (coex_dm->cur_ps_tdma == 14) {
2235 btc8821a2ant_ps_tdma(
2236 btcoexist, NORMAL_EXEC,
2237 true, 14);
2238 coex_dm->ps_tdma_du_adj_type =
2239 14;
2240 }
2241 }
2242 } else {
2243 if (coex_dm->cur_ps_tdma == 5) {
2244 btc8821a2ant_ps_tdma(btcoexist,
2245 NORMAL_EXEC, true, 2);
2246 coex_dm->ps_tdma_du_adj_type = 2;
2247 } else if (coex_dm->cur_ps_tdma == 6) {
2248 btc8821a2ant_ps_tdma(btcoexist,
2249 NORMAL_EXEC, true, 2);
2250 coex_dm->ps_tdma_du_adj_type = 2;
2251 } else if (coex_dm->cur_ps_tdma == 7) {
2252 btc8821a2ant_ps_tdma(btcoexist,
2253 NORMAL_EXEC, true, 3);
2254 coex_dm->ps_tdma_du_adj_type = 3;
2255 } else if (coex_dm->cur_ps_tdma == 8) {
2256 btc8821a2ant_ps_tdma(btcoexist,
2257 NORMAL_EXEC, true, 4);
2258 coex_dm->ps_tdma_du_adj_type = 4;
2259 }
2260 if (coex_dm->cur_ps_tdma == 13) {
2261 btc8821a2ant_ps_tdma(btcoexist,
2262 NORMAL_EXEC, true, 10);
2263 coex_dm->ps_tdma_du_adj_type = 10;
2264 } else if (coex_dm->cur_ps_tdma == 14) {
2265 btc8821a2ant_ps_tdma(btcoexist,
2266 NORMAL_EXEC, true, 10);
2267 coex_dm->ps_tdma_du_adj_type = 10;
2268 } else if (coex_dm->cur_ps_tdma == 15) {
2269 btc8821a2ant_ps_tdma(btcoexist,
2270 NORMAL_EXEC, true, 11);
2271 coex_dm->ps_tdma_du_adj_type = 11;
2272 } else if (coex_dm->cur_ps_tdma == 16) {
2273 btc8821a2ant_ps_tdma(btcoexist,
2274 NORMAL_EXEC, true, 12);
2275 coex_dm->ps_tdma_du_adj_type = 12;
2276 }
2277 if (result == -1) {
2278 if (coex_dm->cur_ps_tdma == 1) {
2279 btc8821a2ant_ps_tdma(
2280 btcoexist, NORMAL_EXEC,
2281 true, 2);
2282 coex_dm->ps_tdma_du_adj_type =
2283 2;
2284 } else if (coex_dm->cur_ps_tdma == 2) {
2285 btc8821a2ant_ps_tdma(
2286 btcoexist, NORMAL_EXEC,
2287 true, 3);
2288 coex_dm->ps_tdma_du_adj_type =
2289 3;
2290 } else if (coex_dm->cur_ps_tdma == 3) {
2291 btc8821a2ant_ps_tdma(
2292 btcoexist, NORMAL_EXEC,
2293 true, 4);
2294 coex_dm->ps_tdma_du_adj_type =
2295 4;
2296 } else if (coex_dm->cur_ps_tdma == 9) {
2297 btc8821a2ant_ps_tdma(
2298 btcoexist, NORMAL_EXEC,
2299 true, 10);
2300 coex_dm->ps_tdma_du_adj_type =
2301 10;
2302 } else if (coex_dm->cur_ps_tdma == 10) {
2303 btc8821a2ant_ps_tdma(
2304 btcoexist, NORMAL_EXEC,
2305 true, 11);
2306 coex_dm->ps_tdma_du_adj_type =
2307 11;
2308 } else if (coex_dm->cur_ps_tdma == 11) {
2309 btc8821a2ant_ps_tdma(
2310 btcoexist, NORMAL_EXEC,
2311 true, 12);
2312 coex_dm->ps_tdma_du_adj_type =
2313 12;
2314 }
2315 } else if (result == 1) {
2316 if (coex_dm->cur_ps_tdma == 4) {
2317 btc8821a2ant_ps_tdma(
2318 btcoexist, NORMAL_EXEC,
2319 true, 3);
2320 coex_dm->ps_tdma_du_adj_type =
2321 3;
2322 } else if (coex_dm->cur_ps_tdma == 3) {
2323 btc8821a2ant_ps_tdma(
2324 btcoexist, NORMAL_EXEC,
2325 true, 2);
2326 coex_dm->ps_tdma_du_adj_type =
2327 2;
2328 } else if (coex_dm->cur_ps_tdma == 2) {
2329 btc8821a2ant_ps_tdma(
2330 btcoexist, NORMAL_EXEC,
2331 true, 2);
2332 coex_dm->ps_tdma_du_adj_type =
2333 2;
2334 } else if (coex_dm->cur_ps_tdma == 12) {
2335 btc8821a2ant_ps_tdma(
2336 btcoexist, NORMAL_EXEC,
2337 true, 11);
2338 coex_dm->ps_tdma_du_adj_type =
2339 11;
2340 } else if (coex_dm->cur_ps_tdma == 11) {
2341 btc8821a2ant_ps_tdma(
2342 btcoexist, NORMAL_EXEC,
2343 true, 10);
2344 coex_dm->ps_tdma_du_adj_type =
2345 10;
2346 } else if (coex_dm->cur_ps_tdma == 10) {
2347 btc8821a2ant_ps_tdma(
2348 btcoexist, NORMAL_EXEC,
2349 true, 10);
2350 coex_dm->ps_tdma_du_adj_type =
2351 10;
2352 }
2353 }
2354 }
2355 } else if (max_interval == 3) {
2356 if (tx_pause) {
2357 if (coex_dm->cur_ps_tdma == 1) {
2358 btc8821a2ant_ps_tdma(btcoexist,
2359 NORMAL_EXEC, true, 7);
2360 coex_dm->ps_tdma_du_adj_type = 7;
2361 } else if (coex_dm->cur_ps_tdma == 2) {
2362 btc8821a2ant_ps_tdma(btcoexist,
2363 NORMAL_EXEC, true, 7);
2364 coex_dm->ps_tdma_du_adj_type = 7;
2365 } else if (coex_dm->cur_ps_tdma == 3) {
2366 btc8821a2ant_ps_tdma(btcoexist,
2367 NORMAL_EXEC, true, 7);
2368 coex_dm->ps_tdma_du_adj_type = 7;
2369 } else if (coex_dm->cur_ps_tdma == 4) {
2370 btc8821a2ant_ps_tdma(btcoexist,
2371 NORMAL_EXEC, true, 8);
2372 coex_dm->ps_tdma_du_adj_type = 8;
2373 }
2374 if (coex_dm->cur_ps_tdma == 9) {
2375 btc8821a2ant_ps_tdma(btcoexist,
2376 NORMAL_EXEC, true, 15);
2377 coex_dm->ps_tdma_du_adj_type = 15;
2378 } else if (coex_dm->cur_ps_tdma == 10) {
2379 btc8821a2ant_ps_tdma(btcoexist,
2380 NORMAL_EXEC, true, 15);
2381 coex_dm->ps_tdma_du_adj_type = 15;
2382 } else if (coex_dm->cur_ps_tdma == 11) {
2383 btc8821a2ant_ps_tdma(btcoexist,
2384 NORMAL_EXEC, true, 15);
2385 coex_dm->ps_tdma_du_adj_type = 15;
2386 } else if (coex_dm->cur_ps_tdma == 12) {
2387 btc8821a2ant_ps_tdma(btcoexist,
2388 NORMAL_EXEC, true, 16);
2389 coex_dm->ps_tdma_du_adj_type = 16;
2390 }
2391 if (result == -1) {
2392 if (coex_dm->cur_ps_tdma == 5) {
2393 btc8821a2ant_ps_tdma(
2394 btcoexist, NORMAL_EXEC,
2395 true, 7);
2396 coex_dm->ps_tdma_du_adj_type =
2397 7;
2398 } else if (coex_dm->cur_ps_tdma == 6) {
2399 btc8821a2ant_ps_tdma(
2400 btcoexist, NORMAL_EXEC,
2401 true, 7);
2402 coex_dm->ps_tdma_du_adj_type =
2403 7;
2404 } else if (coex_dm->cur_ps_tdma == 7) {
2405 btc8821a2ant_ps_tdma(
2406 btcoexist, NORMAL_EXEC,
2407 true, 8);
2408 coex_dm->ps_tdma_du_adj_type =
2409 8;
2410 } else if (coex_dm->cur_ps_tdma == 13) {
2411 btc8821a2ant_ps_tdma(
2412 btcoexist, NORMAL_EXEC,
2413 true, 15);
2414 coex_dm->ps_tdma_du_adj_type =
2415 15;
2416 } else if (coex_dm->cur_ps_tdma == 14) {
2417 btc8821a2ant_ps_tdma(
2418 btcoexist, NORMAL_EXEC,
2419 true, 15);
2420 coex_dm->ps_tdma_du_adj_type =
2421 15;
2422 } else if (coex_dm->cur_ps_tdma == 15) {
2423 btc8821a2ant_ps_tdma(
2424 btcoexist, NORMAL_EXEC,
2425 true, 16);
2426 coex_dm->ps_tdma_du_adj_type =
2427 16;
2428 }
2429 } else if (result == 1) {
2430 if (coex_dm->cur_ps_tdma == 8) {
2431 btc8821a2ant_ps_tdma(
2432 btcoexist, NORMAL_EXEC,
2433 true, 7);
2434 coex_dm->ps_tdma_du_adj_type =
2435 7;
2436 } else if (coex_dm->cur_ps_tdma == 7) {
2437 btc8821a2ant_ps_tdma(
2438 btcoexist, NORMAL_EXEC,
2439 true, 7);
2440 coex_dm->ps_tdma_du_adj_type =
2441 7;
2442 } else if (coex_dm->cur_ps_tdma == 6) {
2443 btc8821a2ant_ps_tdma(
2444 btcoexist, NORMAL_EXEC,
2445 true, 7);
2446 coex_dm->ps_tdma_du_adj_type =
2447 7;
2448 } else if (coex_dm->cur_ps_tdma == 16) {
2449 btc8821a2ant_ps_tdma(
2450 btcoexist, NORMAL_EXEC,
2451 true, 15);
2452 coex_dm->ps_tdma_du_adj_type =
2453 15;
2454 } else if (coex_dm->cur_ps_tdma == 15) {
2455 btc8821a2ant_ps_tdma(
2456 btcoexist, NORMAL_EXEC,
2457 true, 15);
2458 coex_dm->ps_tdma_du_adj_type =
2459 15;
2460 } else if (coex_dm->cur_ps_tdma == 14) {
2461 btc8821a2ant_ps_tdma(
2462 btcoexist, NORMAL_EXEC,
2463 true, 15);
2464 coex_dm->ps_tdma_du_adj_type =
2465 15;
2466 }
2467 }
2468 } else {
2469 if (coex_dm->cur_ps_tdma == 5) {
2470 btc8821a2ant_ps_tdma(btcoexist,
2471 NORMAL_EXEC, true, 3);
2472 coex_dm->ps_tdma_du_adj_type = 3;
2473 } else if (coex_dm->cur_ps_tdma == 6) {
2474 btc8821a2ant_ps_tdma(btcoexist,
2475 NORMAL_EXEC, true, 3);
2476 coex_dm->ps_tdma_du_adj_type = 3;
2477 } else if (coex_dm->cur_ps_tdma == 7) {
2478 btc8821a2ant_ps_tdma(btcoexist,
2479 NORMAL_EXEC, true, 3);
2480 coex_dm->ps_tdma_du_adj_type = 3;
2481 } else if (coex_dm->cur_ps_tdma == 8) {
2482 btc8821a2ant_ps_tdma(btcoexist,
2483 NORMAL_EXEC, true, 4);
2484 coex_dm->ps_tdma_du_adj_type = 4;
2485 }
2486 if (coex_dm->cur_ps_tdma == 13) {
2487 btc8821a2ant_ps_tdma(btcoexist,
2488 NORMAL_EXEC, true, 11);
2489 coex_dm->ps_tdma_du_adj_type = 11;
2490 } else if (coex_dm->cur_ps_tdma == 14) {
2491 btc8821a2ant_ps_tdma(btcoexist,
2492 NORMAL_EXEC, true, 11);
2493 coex_dm->ps_tdma_du_adj_type = 11;
2494 } else if (coex_dm->cur_ps_tdma == 15) {
2495 btc8821a2ant_ps_tdma(btcoexist,
2496 NORMAL_EXEC, true, 11);
2497 coex_dm->ps_tdma_du_adj_type = 11;
2498 } else if (coex_dm->cur_ps_tdma == 16) {
2499 btc8821a2ant_ps_tdma(btcoexist,
2500 NORMAL_EXEC, true, 12);
2501 coex_dm->ps_tdma_du_adj_type = 12;
2502 }
2503 if (result == -1) {
2504 if (coex_dm->cur_ps_tdma == 1) {
2505 btc8821a2ant_ps_tdma(
2506 btcoexist, NORMAL_EXEC,
2507 true, 3);
2508 coex_dm->ps_tdma_du_adj_type =
2509 3;
2510 } else if (coex_dm->cur_ps_tdma == 2) {
2511 btc8821a2ant_ps_tdma(
2512 btcoexist, NORMAL_EXEC,
2513 true, 3);
2514 coex_dm->ps_tdma_du_adj_type =
2515 3;
2516 } else if (coex_dm->cur_ps_tdma == 3) {
2517 btc8821a2ant_ps_tdma(
2518 btcoexist, NORMAL_EXEC,
2519 true, 4);
2520 coex_dm->ps_tdma_du_adj_type =
2521 4;
2522 } else if (coex_dm->cur_ps_tdma == 9) {
2523 btc8821a2ant_ps_tdma(
2524 btcoexist, NORMAL_EXEC,
2525 true, 11);
2526 coex_dm->ps_tdma_du_adj_type =
2527 11;
2528 } else if (coex_dm->cur_ps_tdma == 10) {
2529 btc8821a2ant_ps_tdma(
2530 btcoexist, NORMAL_EXEC,
2531 true, 11);
2532 coex_dm->ps_tdma_du_adj_type =
2533 11;
2534 } else if (coex_dm->cur_ps_tdma == 11) {
2535 btc8821a2ant_ps_tdma(
2536 btcoexist, NORMAL_EXEC,
2537 true, 12);
2538 coex_dm->ps_tdma_du_adj_type =
2539 12;
2540 }
2541 } else if (result == 1) {
2542 if (coex_dm->cur_ps_tdma == 4) {
2543 btc8821a2ant_ps_tdma(
2544 btcoexist, NORMAL_EXEC,
2545 true, 3);
2546 coex_dm->ps_tdma_du_adj_type =
2547 3;
2548 } else if (coex_dm->cur_ps_tdma == 3) {
2549 btc8821a2ant_ps_tdma(
2550 btcoexist, NORMAL_EXEC,
2551 true, 3);
2552 coex_dm->ps_tdma_du_adj_type =
2553 3;
2554 } else if (coex_dm->cur_ps_tdma == 2) {
2555 btc8821a2ant_ps_tdma(
2556 btcoexist, NORMAL_EXEC,
2557 true, 3);
2558 coex_dm->ps_tdma_du_adj_type =
2559 3;
2560 } else if (coex_dm->cur_ps_tdma == 12) {
2561 btc8821a2ant_ps_tdma(
2562 btcoexist, NORMAL_EXEC,
2563 true, 11);
2564 coex_dm->ps_tdma_du_adj_type =
2565 11;
2566 } else if (coex_dm->cur_ps_tdma == 11) {
2567 btc8821a2ant_ps_tdma(
2568 btcoexist, NORMAL_EXEC,
2569 true, 11);
2570 coex_dm->ps_tdma_du_adj_type =
2571 11;
2572 } else if (coex_dm->cur_ps_tdma == 10) {
2573 btc8821a2ant_ps_tdma(
2574 btcoexist, NORMAL_EXEC,
2575 true, 11);
2576 coex_dm->ps_tdma_du_adj_type =
2577 11;
2578 }
2579 }
2580 }
2581 }
2582 }
2583
2584 /* if current PsTdma not match with the recorded one
2585 * (when scan, dhcp...), then we have to adjust it back to
2586 * the previous recorded one.
2587 */
2588 if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2589 bool scan = false, link = false, roam = false;
2590
2591 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2592 "[BTCoex], PsTdma type mismatch!!!, cur_ps_tdma = %d, recordPsTdma = %d\n",
2593 coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2594
2595 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2596 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2597 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2598
2599 if (!scan && !link && !roam) {
2600 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2601 coex_dm->ps_tdma_du_adj_type);
2602 } else {
2603 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2604 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2605 }
2606 }
2607 }
2608
2609 /* SCO only or SCO+PAN(HS)*/
2610 static void btc8821a2ant_action_sco(struct btc_coexist *btcoexist)
2611 {
2612 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2613 u8 wifi_rssi_state, bt_rssi_state;
2614 u32 wifi_bw;
2615
2616 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2617 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist, 2, 35, 0);
2618
2619 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2620
2621 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2622 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2623
2624 if (BTC_RSSI_HIGH(bt_rssi_state))
2625 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2626 else
2627 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2628
2629 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2630
2631 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
2632 /* for SCO quality at 11b/g mode */
2633 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2634 } else {
2635 /* for SCO quality & wifi performance balance at 11n mode */
2636 if (wifi_bw == BTC_WIFI_BW_HT40) {
2637 btc8821a2ant_coex_table_with_type(btcoexist,
2638 NORMAL_EXEC, 8);
2639 } else {
2640 if (bt_link_info->sco_only)
2641 btc8821a2ant_coex_table_with_type(
2642 btcoexist, NORMAL_EXEC, 17);
2643 else
2644 btc8821a2ant_coex_table_with_type(
2645 btcoexist, NORMAL_EXEC, 12);
2646 }
2647 }
2648
2649 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2650 /* for voice quality */
2651 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2652
2653 /* sw mechanism */
2654 if (wifi_bw == BTC_WIFI_BW_HT40) {
2655 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2656 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2657 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2658 false, false);
2659 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2660 true, 0x18);
2661 } else {
2662 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2663 false, false);
2664 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2665 true, 0x18);
2666 }
2667 } else {
2668 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2669 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2670 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2671 false, false);
2672 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2673 true, 0x18);
2674 } else {
2675 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2676 false, false);
2677 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2678 true, 0x18);
2679 }
2680 }
2681 }
2682
2683 static void btc8821a2ant_action_hid(struct btc_coexist *btcoexist)
2684 {
2685 u8 wifi_rssi_state, bt_rssi_state;
2686 u32 wifi_bw;
2687
2688 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2689 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2690 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2691
2692 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2693
2694 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2695 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2696
2697 if (BTC_RSSI_HIGH(bt_rssi_state))
2698 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2699 else
2700 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2701
2702 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2703
2704 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
2705 /* for HID at 11b/g mode */
2706 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2707 } else {
2708 /* for HID quality & wifi performance balance at 11n mode */
2709 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2710 }
2711
2712 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2713 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 24);
2714
2715 if (wifi_bw == BTC_WIFI_BW_HT40) {
2716 /* sw mechanism */
2717 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2718 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2719 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2720 false, false);
2721 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2722 false, 0x18);
2723 } else {
2724 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
2725 false, false);
2726 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2727 false, 0x18);
2728 }
2729 } else {
2730 /* sw mechanism */
2731 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2732 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2733 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2734 false, false);
2735 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2736 false, 0x18);
2737 } else {
2738 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
2739 false, false);
2740 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2741 false, 0x18);
2742 }
2743 }
2744 }
2745
2746 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2747 static void btc8821a2ant_action_a2dp(struct btc_coexist *btcoexist)
2748 {
2749 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2750 u8 ap_num = 0;
2751 u32 wifi_bw;
2752
2753 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2754 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2755 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2756 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2757 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2758
2759 if ((ap_num >= 10) && BTC_RSSI_HIGH(wifi_rssi_state1) &&
2760 BTC_RSSI_HIGH(bt_rssi_state)) {
2761 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2762 0x0, 0x0);
2763
2764 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2765 0x0);
2766 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2767 0x8);
2768 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2769 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2770
2771 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2772
2773 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2774 0x0, 0x0);
2775 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2776
2777 /* sw mechanism */
2778 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2779 if (wifi_bw == BTC_WIFI_BW_HT40) {
2780 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2781 false, false);
2782 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2783 true, 0x6);
2784 } else {
2785 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2786 false, false);
2787 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2788 true, 0x6);
2789 }
2790 return;
2791 }
2792
2793 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2794 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2795
2796 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2797
2798 if (BTC_RSSI_HIGH(bt_rssi_state))
2799 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2800 else
2801 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2802
2803 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2804 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2805 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2806 0x0, 0x0);
2807 } else {
2808 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2809 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2810 0x4);
2811 }
2812
2813 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2814 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2815 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2816 } else {
2817 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2818 }
2819
2820 /* sw mechanism */
2821 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2822 if (wifi_bw == BTC_WIFI_BW_HT40) {
2823 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2824 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2825 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2826 false, false);
2827 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2828 false, 0x18);
2829 } else {
2830 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2831 false, false);
2832 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2833 false, 0x18);
2834 }
2835 } else {
2836 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2837 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2838 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2839 false, false);
2840 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2841 false, 0x18);
2842 } else {
2843 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2844 false, false);
2845 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2846 false, 0x18);
2847 }
2848 }
2849 }
2850
2851 static void btc8821a2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2852 {
2853 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2854 u32 wifi_bw;
2855
2856 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2857 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2858 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2859 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2860 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2861
2862 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2863
2864 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2865 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2866
2867 if (BTC_RSSI_HIGH(bt_rssi_state))
2868 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2869 else
2870 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2871
2872 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2873 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2874 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2875 0x0, 0x0);
2876 } else {
2877 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2878 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2879 0x4);
2880 }
2881
2882 btc8821a2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2883
2884 /* sw mechanism */
2885 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2886 if (wifi_bw == BTC_WIFI_BW_HT40) {
2887 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2888 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2889 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2890 false, false);
2891 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2892 false, 0x18);
2893 } else {
2894 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2895 false, false);
2896 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2897 false, 0x18);
2898 }
2899 } else {
2900 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2901 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2902 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2903 false, false);
2904 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2905 false, 0x18);
2906 } else {
2907 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2908 false, false);
2909 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2910 false, 0x18);
2911 }
2912 }
2913 }
2914
2915 static void btc8821a2ant_action_pan_edr(struct btc_coexist *btcoexist)
2916 {
2917 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2918 u32 wifi_bw;
2919
2920 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2921 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2922 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2923 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2924 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2925
2926 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2927
2928 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2929
2930 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2931
2932 if (BTC_RSSI_HIGH(bt_rssi_state))
2933 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2934 else
2935 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2936
2937 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2938 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 10);
2939 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2940 0x0, 0x0);
2941 } else {
2942 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2943 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2944 0x4);
2945 }
2946
2947 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2948 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2949 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 26);
2950 else
2951 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 26);
2952
2953 /* sw mechanism */
2954 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2955 if (wifi_bw == BTC_WIFI_BW_HT40) {
2956 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2957 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2958 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2959 false, false);
2960 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2961 false, 0x18);
2962 } else {
2963 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
2964 false, false);
2965 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2966 false, 0x18);
2967 }
2968 } else {
2969 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2970 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2971 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2972 false, false);
2973 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
2974 false, 0x18);
2975 } else {
2976 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
2977 false, false);
2978 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
2979 false, 0x18);
2980 }
2981 }
2982 }
2983
2984 /* PAN(HS) only */
2985 static void btc8821a2ant_action_pan_hs(struct btc_coexist *btcoexist)
2986 {
2987 u8 wifi_rssi_state, bt_rssi_state;
2988 u32 wifi_bw;
2989
2990 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2991 btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
2992 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
2993 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
2994 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
2995
2996 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2997
2998 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2999 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3000
3001 if (BTC_RSSI_HIGH(bt_rssi_state))
3002 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3003 else
3004 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3005
3006 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3007 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3008 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3009
3010 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3011 if (wifi_bw == BTC_WIFI_BW_HT40) {
3012 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3013 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3014 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3015 false, false);
3016 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3017 false, 0x18);
3018 } else {
3019 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3020 false, false);
3021 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3022 false, 0x18);
3023 }
3024 } else {
3025 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3026 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3027 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3028 false, false);
3029 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3030 false, 0x18);
3031 } else {
3032 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3033 false, false);
3034 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3035 false, 0x18);
3036 }
3037 }
3038 }
3039
3040 /* PAN(EDR)+A2DP */
3041 static void btc8821a2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
3042 {
3043 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3044 u32 wifi_bw;
3045
3046 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3047 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3048 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3049 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3050 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3051
3052 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3053
3054 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3055
3056 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3057
3058 if (BTC_RSSI_HIGH(bt_rssi_state))
3059 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3060 else
3061 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3062
3063 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state))
3064 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3065 0x0, 0x0);
3066 else
3067 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3068 0x4);
3069
3070 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3071
3072 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3073 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3074 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
3075
3076 if (wifi_bw == BTC_WIFI_BW_HT40)
3077 btc8821a2ant_tdma_duration_adjust(btcoexist, false,
3078 true, 3);
3079 else
3080 btc8821a2ant_tdma_duration_adjust(btcoexist, false,
3081 false, 3);
3082 } else {
3083 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3084 btc8821a2ant_tdma_duration_adjust(btcoexist, false, true, 3);
3085 }
3086
3087 /* sw mechanism */
3088 if (wifi_bw == BTC_WIFI_BW_HT40) {
3089 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3090 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3091 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3092 false, false);
3093 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3094 false, 0x18);
3095 } else {
3096 btc8821a2ant_sw_mechanism1(btcoexist, true, false,
3097 false, false);
3098 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3099 false, 0x18);
3100 }
3101 } else {
3102 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3103 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3104 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3105 false, false);
3106 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3107 false, 0x18);
3108 } else {
3109 btc8821a2ant_sw_mechanism1(btcoexist, false, false,
3110 false, false);
3111 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3112 false, 0x18);
3113 }
3114 }
3115 }
3116
3117 static void btc8821a2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
3118 {
3119 u8 wifi_rssi_state, bt_rssi_state;
3120 u32 wifi_bw;
3121
3122 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3123 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3124 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3125
3126 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3127
3128 if (BTC_RSSI_HIGH(bt_rssi_state))
3129 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
3130 else
3131 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
3132
3133 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3134
3135 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3136 /* for HID at 11b/g mode */
3137 btc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3138 0x5a5f5a5f, 0xffff, 0x3);
3139 } else {
3140 /* for HID quality & wifi performance balance at 11n mode */
3141 btc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3142 0x5a5f5a5f, 0xffff, 0x3);
3143 }
3144
3145 if (wifi_bw == BTC_WIFI_BW_HT40) {
3146 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 3);
3147 /* fw mechanism */
3148 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3149 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3150 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3151 true, 10);
3152 } else {
3153 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
3154 }
3155
3156 /* sw mechanism */
3157 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3158 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3159 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3160 false, false);
3161 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3162 false, 0x18);
3163 } else {
3164 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3165 false, false);
3166 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3167 false, 0x18);
3168 }
3169 } else {
3170 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3171 /* fw mechanism */
3172 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3173 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3174 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
3175 } else {
3176 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
3177 }
3178
3179 /* sw mechanism */
3180 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3181 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3182 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3183 false, false);
3184 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3185 false, 0x18);
3186 } else {
3187 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3188 false, false);
3189 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3190 false, 0x18);
3191 }
3192 }
3193 }
3194
3195 /* HID+A2DP+PAN(EDR) */
3196 static void btc8821a2ant_act_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
3197 {
3198 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3199 u32 wifi_bw;
3200
3201 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3202 wifi_rssi_state1 = btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3203 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3204 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3205 2, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 0);
3206
3207 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3208
3209 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3210 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3211
3212 if (BTC_RSSI_HIGH(bt_rssi_state))
3213 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3214 else
3215 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3216
3217 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3218 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3219 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3220 0x0, 0x0);
3221 } else {
3222 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3223 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3224 0x4);
3225 }
3226
3227 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3228
3229 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3230 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3231 if (wifi_bw == BTC_WIFI_BW_HT40)
3232 btc8821a2ant_tdma_duration_adjust(btcoexist, true,
3233 true, 3);
3234 else
3235 btc8821a2ant_tdma_duration_adjust(btcoexist, true,
3236 false, 3);
3237 } else {
3238 btc8821a2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3239 }
3240
3241 /* sw mechanism */
3242 if (wifi_bw == BTC_WIFI_BW_HT40) {
3243 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3244 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3245 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3246 false, false);
3247 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3248 false, 0x18);
3249 } else {
3250 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3251 false, false);
3252 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3253 false, 0x18);
3254 }
3255 } else {
3256 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3257 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3258 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3259 false, false);
3260 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3261 false, 0x18);
3262 } else {
3263 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3264 false, false);
3265 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3266 false, 0x18);
3267 }
3268 }
3269 }
3270
3271 static void btc8821a2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3272 {
3273 u32 wifi_bw;
3274 u8 wifi_rssi_state, bt_rssi_state;
3275 u8 ap_num = 0;
3276
3277 wifi_rssi_state = btc8821a2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3278 btc8821a2ant_wifi_rssi_state(btcoexist, 1, 2,
3279 BT_8821A_2ANT_WIFI_RSSI_COEXSWITCH_THRES, 0);
3280 bt_rssi_state = btc8821a2ant_bt_rssi_state(btcoexist,
3281 3, BT_8821A_2ANT_BT_RSSI_COEXSWITCH_THRES, 37);
3282
3283 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3284
3285 btc8821a2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3286 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3287
3288 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3289 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3290 if (BTC_RSSI_HIGH(bt_rssi_state))
3291 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3292 else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3293 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3294 else
3295 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3296 } else {
3297 /* only 802.11N mode we have to dec bt power to 4 degree */
3298 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3299 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3300 &ap_num);
3301 if (ap_num < 10)
3302 btc8821a2ant_dec_bt_pwr(btcoexist,
3303 NORMAL_EXEC, 4);
3304 else
3305 btc8821a2ant_dec_bt_pwr(btcoexist,
3306 NORMAL_EXEC, 2);
3307 } else if (BTC_RSSI_MEDIUM(bt_rssi_state)) {
3308 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3309 } else {
3310 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3311 }
3312 }
3313
3314 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3315 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3316 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3317 0x0, 0x0);
3318 } else {
3319 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3320 btc8821a2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3321 0x4);
3322 }
3323
3324 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3325 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3326 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
3327 } else {
3328 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
3329 }
3330
3331 /* sw mechanism */
3332 if (wifi_bw == BTC_WIFI_BW_HT40) {
3333 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3334 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3335 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3336 false, false);
3337 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3338 false, 0x18);
3339 } else {
3340 btc8821a2ant_sw_mechanism1(btcoexist, true, true,
3341 false, false);
3342 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3343 false, 0x18);
3344 }
3345 } else {
3346 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3347 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3348 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3349 false, false);
3350 btc8821a2ant_sw_mechanism2(btcoexist, true, false,
3351 false, 0x18);
3352 } else {
3353 btc8821a2ant_sw_mechanism1(btcoexist, false, true,
3354 false, false);
3355 btc8821a2ant_sw_mechanism2(btcoexist, false, false,
3356 false, 0x18);
3357 }
3358 }
3359 }
3360
3361 static void btc8821a2ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
3362 {
3363 btc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3364 btc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3365
3366 /* sw all off */
3367 btc8821a2ant_sw_mechanism1(btcoexist, false, false, false, false);
3368 btc8821a2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
3369
3370 /* hw all off */
3371 btc8821a2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3372
3373 btc8821a2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3374 btc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3375 }
3376
3377 static void btc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3378 {
3379 struct rtl_priv *rtlpriv = btcoexist->adapter;
3380 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3381 bool wifi_under_5g = false;
3382 u8 algorithm = 0;
3383 u32 num_of_wifi_link = 0;
3384 u32 wifi_link_status = 0;
3385 bool miracast_plus_bt = false;
3386 bool scan = false, link = false, roam = false;
3387
3388 if (btcoexist->manual_control) {
3389 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3390 "[BTCoex], Manual control!!!\n");
3391 return;
3392 }
3393
3394 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3395
3396 if (wifi_under_5g) {
3397 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3398 "[BTCoex], RunCoexistMechanism(), run 5G coex setting!!<===\n");
3399 btc8821a2ant_coex_under_5g(btcoexist);
3400 return;
3401 }
3402
3403 if (coex_sta->under_ips) {
3404 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3405 "[BTCoex], wifi is under IPS !!!\n");
3406 return;
3407 }
3408
3409 algorithm = btc8821a2ant_action_algorithm(btcoexist);
3410 if (coex_sta->c2h_bt_inquiry_page &&
3411 (BT_8821A_2ANT_COEX_ALGO_PANHS != algorithm)) {
3412 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3413 "[BTCoex], BT is under inquiry/page scan !!\n");
3414 btc8821a2ant_action_bt_inquiry(btcoexist);
3415 return;
3416 }
3417
3418 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3419 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3420 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3421
3422 if (scan || link || roam) {
3423 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3424 "[BTCoex], WiFi is under Link Process !!\n");
3425 btc8821a2ant_action_wifi_link_process(btcoexist);
3426 return;
3427 }
3428
3429 /* for P2P */
3430 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3431 &wifi_link_status);
3432 num_of_wifi_link = wifi_link_status >> 16;
3433
3434 if ((num_of_wifi_link >= 2) ||
3435 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3436 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3437 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3438 num_of_wifi_link, wifi_link_status);
3439
3440 if (bt_link_info->bt_link_exist)
3441 miracast_plus_bt = true;
3442 else
3443 miracast_plus_bt = false;
3444
3445 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3446 &miracast_plus_bt);
3447 btc8821a2ant_action_wifi_multi_port(btcoexist);
3448
3449 return;
3450 }
3451
3452 miracast_plus_bt = false;
3453 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3454 &miracast_plus_bt);
3455
3456 coex_dm->cur_algorithm = algorithm;
3457 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3458 "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
3459
3460 if (btc8821a2ant_is_common_action(btcoexist)) {
3461 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3462 "[BTCoex], Action 2-Ant common\n");
3463 coex_dm->auto_tdma_adjust = true;
3464 } else {
3465 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3466 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3467 "[BTCoex], pre_algorithm = %d, cur_algorithm = %d\n",
3468 coex_dm->pre_algorithm,
3469 coex_dm->cur_algorithm);
3470 coex_dm->auto_tdma_adjust = false;
3471 }
3472 switch (coex_dm->cur_algorithm) {
3473 case BT_8821A_2ANT_COEX_ALGO_SCO:
3474 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3475 "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3476 btc8821a2ant_action_sco(btcoexist);
3477 break;
3478 case BT_8821A_2ANT_COEX_ALGO_HID:
3479 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3480 "[BTCoex], Action 2-Ant, algorithm = HID\n");
3481 btc8821a2ant_action_hid(btcoexist);
3482 break;
3483 case BT_8821A_2ANT_COEX_ALGO_A2DP:
3484 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3485 "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3486 btc8821a2ant_action_a2dp(btcoexist);
3487 break;
3488 case BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS:
3489 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3490 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3491 btc8821a2ant_action_a2dp_pan_hs(btcoexist);
3492 break;
3493 case BT_8821A_2ANT_COEX_ALGO_PANEDR:
3494 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3495 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3496 btc8821a2ant_action_pan_edr(btcoexist);
3497 break;
3498 case BT_8821A_2ANT_COEX_ALGO_PANHS:
3499 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3500 "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3501 btc8821a2ant_action_pan_hs(btcoexist);
3502 break;
3503 case BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP:
3504 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3505 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3506 btc8821a2ant_action_pan_edr_a2dp(btcoexist);
3507 break;
3508 case BT_8821A_2ANT_COEX_ALGO_PANEDR_HID:
3509 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3510 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3511 btc8821a2ant_action_pan_edr_hid(btcoexist);
3512 break;
3513 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3514 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3515 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3516 btc8821a2ant_act_hid_a2dp_pan_edr(btcoexist);
3517 break;
3518 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP:
3519 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3520 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3521 btc8821a2ant_action_hid_a2dp(btcoexist);
3522 break;
3523 default:
3524 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3525 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3526 btc8821a2ant_coex_all_off(btcoexist);
3527 break;
3528 }
3529 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3530 }
3531 }
3532
3533 static void btc8821a2ant_wifi_off_hw_cfg(struct btc_coexist *btcoexist)
3534 {
3535 u8 h2c_parameter[2] = {0};
3536 u32 fw_ver = 0;
3537
3538 /* set wlan_act to low */
3539 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3540
3541 /* WiFi goto standby while GNT_BT 0-->1 */
3542 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
3543 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3544 if (fw_ver >= 0x180000) {
3545 /* Use H2C to set GNT_BT to HIGH */
3546 h2c_parameter[0] = 1;
3547 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
3548 } else {
3549 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
3550 }
3551 }
3552
3553 /**************************************************************
3554 * extern function start with ex_btc8821a2ant_
3555 **************************************************************/
3556 void ex_btc8821a2ant_init_hwconfig(struct btc_coexist *btcoexist)
3557 {
3558 struct rtl_priv *rtlpriv = btcoexist->adapter;
3559 u8 u1tmp = 0;
3560
3561 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3562 "[BTCoex], 2Ant Init HW Config!!\n");
3563
3564 /* backup rf 0x1e value */
3565 coex_dm->bt_rf0x1e_backup =
3566 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3567
3568 /* 0x790[5:0] = 0x5 */
3569 u1tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3570 u1tmp &= 0xc0;
3571 u1tmp |= 0x5;
3572 btcoexist->btc_write_1byte(btcoexist, 0x790, u1tmp);
3573
3574 /* Antenna config */
3575 btc8821a2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN, true, false);
3576 coex_sta->dis_ver_info_cnt = 0;
3577
3578 /* PTA parameter */
3579 btc8821a2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3580
3581 /* Enable counter statistics */
3582 /* 0x76e[3] = 1, WLAN_Act control by PTA */
3583 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3584 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3585 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3586 }
3587
3588 void ex_btc8821a2ant_pre_load_firmware(struct btc_coexist *btcoexist)
3589 {
3590 struct btc_board_info *board_info = &btcoexist->board_info;
3591 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
3592
3593 /**
3594 * S0 or S1 setting and Local register setting(By the setting fw can get
3595 * ant number, S0/S1, ... info)
3596 *
3597 * Local setting bit define
3598 * BIT0: "0" for no antenna inverse; "1" for antenna inverse
3599 * BIT1: "0" for internal switch; "1" for external switch
3600 * BIT2: "0" for one antenna; "1" for two antenna
3601 * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
3602 * BIT2=0
3603 */
3604 if (btcoexist->chip_interface == BTC_INTF_USB) {
3605 /* fixed at S0 for USB interface */
3606 u8tmp |= 0x1; /* antenna inverse */
3607 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3608 } else {
3609 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3610 if (board_info->single_ant_path == 0) {
3611 } else if (board_info->single_ant_path == 1) {
3612 /* set to S0 */
3613 u8tmp |= 0x1; /* antenna inverse */
3614 }
3615
3616 if (btcoexist->chip_interface == BTC_INTF_PCI)
3617 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
3618 u8tmp);
3619 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3620 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
3621 u8tmp);
3622 }
3623 }
3624
3625 void ex_btc8821a2ant_init_coex_dm(struct btc_coexist *btcoexist)
3626 {
3627 struct rtl_priv *rtlpriv = btcoexist->adapter;
3628
3629 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3630 "[BTCoex], Coex Mechanism Init!!\n");
3631
3632 btc8821a2ant_init_coex_dm(btcoexist);
3633 }
3634
3635 void ex_btc8821a2ant_display_coex_info(struct btc_coexist *btcoexist,
3636 struct seq_file *m)
3637 {
3638 struct btc_board_info *board_info = &btcoexist->board_info;
3639 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3640 u8 u1tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3641 u32 u4tmp[4];
3642 bool roam = false, scan = false, link = false, wifi_under_5g = false;
3643 bool bt_hs_on = false, wifi_busy = false;
3644 long wifi_rssi = 0, bt_hs_rssi = 0;
3645 u32 wifi_bw, wifi_traffic_dir;
3646 u8 wifi_dot_11_chnl, wifi_hs_chnl;
3647 u32 fw_ver = 0, bt_patch_ver = 0;
3648
3649 seq_puts(m, "\n ============[BT Coexist info]============");
3650
3651 seq_printf(m, "\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:",
3652 board_info->pg_ant_num, board_info->btdm_ant_num);
3653
3654 if (btcoexist->manual_control) {
3655 seq_printf(m, "\n %-35s", "[Action Manual control]!!");
3656 }
3657
3658 seq_printf(m, "\n %-35s = %s / %d", "BT stack/ hci ext ver",
3659 ((stack_info->profile_notified) ? "Yes" : "No"),
3660 stack_info->hci_version);
3661
3662 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3663 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3664 seq_printf(m, "\n %-35s = %d_%d/ 0x%x/ 0x%x(%d)",
3665 "CoexVer/ FwVer/ PatchVer",
3666 glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
3667 fw_ver, bt_patch_ver, bt_patch_ver);
3668
3669 btcoexist->btc_get(btcoexist,
3670 BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3671 btcoexist->btc_get(btcoexist,
3672 BTC_GET_U1_WIFI_DOT11_CHNL, &wifi_dot_11_chnl);
3673 btcoexist->btc_get(btcoexist,
3674 BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3675 seq_printf(m, "\n %-35s = %d / %d(%d)",
3676 "Dot11 channel / HsMode(HsChnl)",
3677 wifi_dot_11_chnl, bt_hs_on, wifi_hs_chnl);
3678
3679 seq_printf(m, "\n %-35s = %3ph ",
3680 "H2C Wifi inform bt chnl Info",
3681 coex_dm->wifi_chnl_info);
3682
3683 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3684 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3685 seq_printf(m, "\n %-35s = %ld/ %ld", "Wifi rssi/ HS rssi",
3686 wifi_rssi, bt_hs_rssi);
3687
3688 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3689 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3690 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3691 seq_printf(m, "\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
3692 link, roam, scan);
3693
3694 btcoexist->btc_get(btcoexist,
3695 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3696 btcoexist->btc_get(btcoexist,
3697 BTC_GET_U4_WIFI_BW, &wifi_bw);
3698 btcoexist->btc_get(btcoexist,
3699 BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3700 btcoexist->btc_get(btcoexist,
3701 BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifi_traffic_dir);
3702 seq_printf(m, "\n %-35s = %s / %s/ %s ", "Wifi status",
3703 (wifi_under_5g ? "5G" : "2.4G"),
3704 ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3705 (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3706 ((!wifi_busy) ? "idle" :
3707 ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3708 "uplink" : "downlink")));
3709
3710 if (stack_info->profile_notified) {
3711 seq_printf(m, "\n %-35s = %d / %d / %d / %d",
3712 "SCO/HID/PAN/A2DP",
3713 stack_info->sco_exist, stack_info->hid_exist,
3714 stack_info->pan_exist, stack_info->a2dp_exist);
3715
3716 btcoexist->btc_disp_dbg_msg(btcoexist,
3717 BTC_DBG_DISP_BT_LINK_INFO,
3718 m);
3719 }
3720
3721 bt_info_ext = coex_sta->bt_info_ext;
3722 seq_printf(m, "\n %-35s = %s", "BT Info A2DP rate",
3723 (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3724
3725 for (i = 0; i < BT_INFO_SRC_8821A_2ANT_MAX; i++) {
3726 if (coex_sta->bt_info_c2h_cnt[i]) {
3727 seq_printf(m, "\n %-35s = %7ph(%d)",
3728 glbt_info_src_8821a_2ant[i],
3729 coex_sta->bt_info_c2h[i],
3730 coex_sta->bt_info_c2h_cnt[i]);
3731 }
3732 }
3733
3734 seq_printf(m, "\n %-35s = %s/%s",
3735 "PS state, IPS/LPS",
3736 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3737 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3738 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
3739
3740 /* Sw mechanism*/
3741 seq_printf(m, "\n %-35s",
3742 "============[Sw mechanism]============");
3743 seq_printf(m, "\n %-35s = %d/ %d/ %d(0x%x) ",
3744 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3745 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3746 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3747
3748 /* Fw mechanism*/
3749 seq_printf(m, "\n %-35s",
3750 "============[Fw mechanism]============");
3751
3752 if (!btcoexist->manual_control) {
3753 ps_tdma_case = coex_dm->cur_ps_tdma;
3754 seq_printf(m, "\n %-35s = %5ph case-%d",
3755 "PS TDMA",
3756 coex_dm->ps_tdma_para, ps_tdma_case);
3757
3758 seq_printf(m, "\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct",
3759 coex_dm->cur_dec_bt_pwr_lvl,
3760 coex_dm->cur_ignore_wlan_act);
3761 }
3762
3763 /* Hw setting*/
3764 seq_printf(m, "\n %-35s", "============[Hw setting]============");
3765
3766 seq_printf(m, "\n %-35s = 0x%x", "RF-A, 0x1e initVal",
3767 coex_dm->bt_rf0x1e_backup);
3768
3769 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3770 u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3771 seq_printf(m, "\n %-35s = 0x%x/ 0x%x ",
3772 "0x778 (W_Act)/ 0x6cc (CoTab Sel)",
3773 u1tmp[0], u1tmp[1]);
3774
3775 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
3776 u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xc5b);
3777 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3778 "0x8db(ADC)/0xc5b[29:25](DAC)",
3779 ((u1tmp[0] & 0x60) >> 5), ((u1tmp[1] & 0x3e) >> 1));
3780
3781 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
3782 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3783 "0xcb4[7:0](ctrl)/ 0xcb4[29:28](val)",
3784 u4tmp[0] & 0xff, ((u4tmp[0] & 0x30000000) >> 28));
3785
3786 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3787 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3788 u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x974);
3789 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3790 "0x40/ 0x4c[24:23]/ 0x974",
3791 u1tmp[0], ((u4tmp[0] & 0x01800000) >> 23), u4tmp[1]);
3792
3793 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3794 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3795 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3796 "0x550(bcn ctrl)/0x522",
3797 u4tmp[0], u1tmp[0]);
3798
3799 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3800 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa0a);
3801 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3802 "0xc50(DIG)/0xa0a(CCK-TH)",
3803 u4tmp[0], u1tmp[0]);
3804
3805 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
3806 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3807 u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3808 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3809 "OFDM-FA/ CCK-FA",
3810 u4tmp[0], (u1tmp[0] << 8) + u1tmp[1]);
3811
3812 u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3813 u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3814 u4tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3815 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3816 "0x6c0/0x6c4/0x6c8",
3817 u4tmp[0], u4tmp[1], u4tmp[2]);
3818
3819 seq_printf(m, "\n %-35s = %d/ %d",
3820 "0x770 (hi-pri Rx/Tx)",
3821 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3822 seq_printf(m, "\n %-35s = %d/ %d",
3823 "0x774(low-pri Rx/Tx)",
3824 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
3825
3826 /* Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang*/
3827 u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x41b);
3828 seq_printf(m, "\n %-35s = 0x%x",
3829 "0x41b (mgntQ hang chk == 0xf)",
3830 u1tmp[0]);
3831
3832 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
3833 }
3834
3835 void ex_btc8821a2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3836 {
3837 struct rtl_priv *rtlpriv = btcoexist->adapter;
3838
3839 if (BTC_IPS_ENTER == type) {
3840 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3841 "[BTCoex], IPS ENTER notify\n");
3842 coex_sta->under_ips = true;
3843 btc8821a2ant_wifi_off_hw_cfg(btcoexist);
3844 btc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3845 btc8821a2ant_coex_all_off(btcoexist);
3846 } else if (BTC_IPS_LEAVE == type) {
3847 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3848 "[BTCoex], IPS LEAVE notify\n");
3849 coex_sta->under_ips = false;
3850 ex_btc8821a2ant_init_hwconfig(btcoexist);
3851 btc8821a2ant_init_coex_dm(btcoexist);
3852 btc8821a2ant_query_bt_info(btcoexist);
3853 }
3854 }
3855
3856 void ex_btc8821a2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3857 {
3858 struct rtl_priv *rtlpriv = btcoexist->adapter;
3859
3860 if (BTC_LPS_ENABLE == type) {
3861 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3862 "[BTCoex], LPS ENABLE notify\n");
3863 coex_sta->under_lps = true;
3864 } else if (BTC_LPS_DISABLE == type) {
3865 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3866 "[BTCoex], LPS DISABLE notify\n");
3867 coex_sta->under_lps = false;
3868 }
3869 }
3870
3871 void ex_btc8821a2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3872 {
3873 struct rtl_priv *rtlpriv = btcoexist->adapter;
3874
3875 if (BTC_SCAN_START == type) {
3876 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3877 "[BTCoex], SCAN START notify\n");
3878 } else if (BTC_SCAN_FINISH == type) {
3879 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3880 "[BTCoex], SCAN FINISH notify\n");
3881 }
3882 }
3883
3884 void ex_btc8821a2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3885 {
3886 struct rtl_priv *rtlpriv = btcoexist->adapter;
3887
3888 if (BTC_ASSOCIATE_START == type) {
3889 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3890 "[BTCoex], CONNECT START notify\n");
3891 } else if (BTC_ASSOCIATE_FINISH == type) {
3892 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3893 "[BTCoex], CONNECT FINISH notify\n");
3894 }
3895 }
3896
3897 void ex_btc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
3898 u8 type)
3899 {
3900 struct rtl_priv *rtlpriv = btcoexist->adapter;
3901 u8 h2c_parameter[3] = {0};
3902 u32 wifi_bw;
3903 u8 wifi_central_chnl;
3904 u8 ap_num = 0;
3905
3906 if (BTC_MEDIA_CONNECT == type) {
3907 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3908 "[BTCoex], MEDIA connect notify\n");
3909 } else {
3910 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3911 "[BTCoex], MEDIA disconnect notify\n");
3912 }
3913
3914 /* only 2.4G we need to inform bt the chnl mask */
3915 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
3916 &wifi_central_chnl);
3917 if ((BTC_MEDIA_CONNECT == type) &&
3918 (wifi_central_chnl <= 14)) {
3919 h2c_parameter[0] = 0x1;
3920 h2c_parameter[1] = wifi_central_chnl;
3921 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3922 if (wifi_bw == BTC_WIFI_BW_HT40) {
3923 h2c_parameter[2] = 0x30;
3924 } else {
3925 h2c_parameter[2] = 0x20;
3926 if (ap_num < 10)
3927 h2c_parameter[2] = 0x30;
3928 else
3929 h2c_parameter[2] = 0x20;
3930 }
3931 }
3932
3933 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3934 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3935 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3936
3937 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3938 "[BTCoex], FW write 0x66 = 0x%x\n",
3939 h2c_parameter[0] << 16 |
3940 h2c_parameter[1] << 8 |
3941 h2c_parameter[2]);
3942
3943 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3944 }
3945
3946 void ex_btc8821a2ant_special_packet_notify(struct btc_coexist *btcoexist,
3947 u8 type)
3948 {
3949 struct rtl_priv *rtlpriv = btcoexist->adapter;
3950
3951 if (type == BTC_PACKET_DHCP) {
3952 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3953 "[BTCoex], DHCP Packet notify\n");
3954 }
3955 }
3956
3957 void ex_btc8821a2ant_bt_info_notify(struct btc_coexist *btcoexist,
3958 u8 *tmp_buf, u8 length)
3959 {
3960 struct rtl_priv *rtlpriv = btcoexist->adapter;
3961 u8 bt_info = 0;
3962 u8 i, rsp_source = 0;
3963 bool bt_busy = false, limited_dig = false;
3964 bool wifi_connected = false, wifi_under_5g = false;
3965
3966 coex_sta->c2h_bt_info_req_sent = false;
3967 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3968 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3969 &wifi_connected);
3970
3971 rsp_source = tmp_buf[0] & 0xf;
3972 if (rsp_source >= BT_INFO_SRC_8821A_2ANT_MAX)
3973 rsp_source = BT_INFO_SRC_8821A_2ANT_WIFI_FW;
3974 coex_sta->bt_info_c2h_cnt[rsp_source]++;
3975
3976 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3977 "[BTCoex], Bt info[%d], length = %d, hex data = [",
3978 rsp_source, length);
3979 for (i = 0; i < length; i++) {
3980 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3981 if (i == 1)
3982 bt_info = tmp_buf[i];
3983 if (i == length - 1) {
3984 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3985 "0x%02x]\n", tmp_buf[i]);
3986 } else {
3987 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3988 "0x%02x, ", tmp_buf[i]);
3989 }
3990 }
3991
3992 if (btcoexist->manual_control) {
3993 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3994 "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
3995 return;
3996 }
3997
3998 if (BT_INFO_SRC_8821A_2ANT_WIFI_FW != rsp_source) {
3999 /* [3:0] */
4000 coex_sta->bt_retry_cnt =
4001 coex_sta->bt_info_c2h[rsp_source][2]&0xf;
4002
4003 coex_sta->bt_rssi =
4004 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4005
4006 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4007
4008 coex_sta->bt_tx_rx_mask =
4009 (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
4010 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
4011 &coex_sta->bt_tx_rx_mask);
4012 if (coex_sta->bt_tx_rx_mask) {
4013 /* BT into is responded by BT FW and BT RF REG 0x3C !=
4014 * 0x01 => Need to switch BT TRx Mask
4015 */
4016 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4017 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n");
4018 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
4019 0x3c, 0x01);
4020 }
4021
4022 /* Here we need to resend some wifi info to BT
4023 * because bt is reset and loss of the info
4024 */
4025 if ((coex_sta->bt_info_ext & BIT1)) {
4026 btcoexist->btc_get(btcoexist,
4027 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
4028 if (wifi_connected) {
4029 ex_btc8821a2ant_media_status_notify(btcoexist,
4030 BTC_MEDIA_CONNECT);
4031 } else {
4032 ex_btc8821a2ant_media_status_notify(btcoexist,
4033 BTC_MEDIA_DISCONNECT);
4034 }
4035
4036 }
4037
4038 if (!btcoexist->manual_control && !wifi_under_5g) {
4039 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4040 "[BTCoex], BT ext info = 0x%x!!\n",
4041 coex_sta->bt_info_ext);
4042 if ((coex_sta->bt_info_ext & BIT(3))) {
4043 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4044 "[BTCoex], BT ext info bit3=1, wifi_connected=%d\n",
4045 wifi_connected);
4046 if (wifi_connected) {
4047 rtl_dbg(rtlpriv, COMP_BT_COEXIST,
4048 DBG_LOUD,
4049 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4050 btc8821a2ant_ignore_wlan_act(btcoexist,
4051 FORCE_EXEC,
4052 false);
4053 }
4054 } else {
4055 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4056 "[BTCoex], BT ext info bit3=0, wifi_connected=%d\n",
4057 wifi_connected);
4058 /* BT already NOT ignore Wlan active, do nothing
4059 * here.
4060 */
4061 if (!wifi_connected) {
4062 rtl_dbg(rtlpriv, COMP_BT_COEXIST,
4063 DBG_LOUD,
4064 "[BTCoex], BT ext info bit3 check, set BT to ignore Wlan active!!\n");
4065 btc8821a2ant_ignore_wlan_act(
4066 btcoexist, FORCE_EXEC, true);
4067 }
4068 }
4069 }
4070 }
4071
4072 /* check BIT2 first ==> check if bt is under inquiry or page scan*/
4073 if (bt_info & BT_INFO_8821A_2ANT_B_INQ_PAGE) {
4074 coex_sta->c2h_bt_inquiry_page = true;
4075 } else {
4076 coex_sta->c2h_bt_inquiry_page = false;
4077 }
4078 /* set link exist status */
4079 if (!(bt_info & BT_INFO_8821A_2ANT_B_CONNECTION)) {
4080 coex_sta->bt_link_exist = false;
4081 coex_sta->pan_exist = false;
4082 coex_sta->a2dp_exist = false;
4083 coex_sta->hid_exist = false;
4084 coex_sta->sco_exist = false;
4085 } else { /* connection exists */
4086 coex_sta->bt_link_exist = true;
4087 if (bt_info & BT_INFO_8821A_2ANT_B_FTP)
4088 coex_sta->pan_exist = true;
4089 else
4090 coex_sta->pan_exist = false;
4091 if (bt_info & BT_INFO_8821A_2ANT_B_A2DP)
4092 coex_sta->a2dp_exist = true;
4093 else
4094 coex_sta->a2dp_exist = false;
4095 if (bt_info & BT_INFO_8821A_2ANT_B_HID)
4096 coex_sta->hid_exist = true;
4097 else
4098 coex_sta->hid_exist = false;
4099 if (bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO)
4100 coex_sta->sco_exist = true;
4101 else
4102 coex_sta->sco_exist = false;
4103
4104 if ((!coex_sta->hid_exist) &&
4105 (!coex_sta->c2h_bt_inquiry_page) &&
4106 (!coex_sta->sco_exist)) {
4107 if (coex_sta->high_priority_tx +
4108 coex_sta->high_priority_rx >= 160)
4109 coex_sta->hid_exist = true;
4110 }
4111 }
4112
4113 btc8821a2ant_update_bt_link_info(btcoexist);
4114
4115 if (!(bt_info & BT_INFO_8821A_2ANT_B_CONNECTION)) {
4116 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_IDLE;
4117 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4118 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4119 } else if (bt_info == BT_INFO_8821A_2ANT_B_CONNECTION) {
4120 /* connection exists but no busy */
4121 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_CON_IDLE;
4122 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4123 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4124 } else if ((bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO) ||
4125 (bt_info & BT_INFO_8821A_2ANT_B_SCO_BUSY)) {
4126 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_SCO_BUSY;
4127 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4128 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4129 } else if (bt_info & BT_INFO_8821A_2ANT_B_ACL_BUSY) {
4130 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_ACL_BUSY;
4131 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4132 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4133 } else {
4134 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_MAX;
4135 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4136 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4137 }
4138
4139 if ((coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_ACL_BUSY) ||
4140 (coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_SCO_BUSY) ||
4141 (coex_dm->bt_status == BT_8821A_2ANT_BT_STATUS_ACL_SCO_BUSY)) {
4142 bt_busy = true;
4143 limited_dig = true;
4144 } else {
4145 bt_busy = false;
4146 limited_dig = false;
4147 }
4148
4149 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4150
4151 coex_dm->limited_dig = limited_dig;
4152 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4153
4154 btc8821a2ant_run_coexist_mechanism(btcoexist);
4155 }
4156
4157 void ex_btc8821a2ant_halt_notify(struct btc_coexist *btcoexist)
4158 {
4159 struct rtl_priv *rtlpriv = btcoexist->adapter;
4160
4161 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4162 "[BTCoex], Halt notify\n");
4163
4164 btc8821a2ant_wifi_off_hw_cfg(btcoexist);
4165 btc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4166 ex_btc8821a2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4167 }
4168
4169 void ex_btc8821a2ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
4170 {
4171 struct rtl_priv *rtlpriv = btcoexist->adapter;
4172
4173 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
4174
4175 if (pnp_state == BTC_WIFI_PNP_SLEEP) {
4176 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4177 "[BTCoex], Pnp notify to SLEEP\n");
4178 } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
4179 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4180 "[BTCoex], Pnp notify to WAKE UP\n");
4181 ex_btc8821a2ant_init_hwconfig(btcoexist);
4182 btc8821a2ant_init_coex_dm(btcoexist);
4183 btc8821a2ant_query_bt_info(btcoexist);
4184 }
4185 }
4186
4187 void ex_btc8821a2ant_periodical(struct btc_coexist *btcoexist)
4188 {
4189 struct rtl_priv *rtlpriv = btcoexist->adapter;
4190
4191 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4192 "[BTCoex], ==========================Periodical===========================\n");
4193
4194 if (coex_sta->dis_ver_info_cnt <= 5) {
4195 coex_sta->dis_ver_info_cnt += 1;
4196 if (coex_sta->dis_ver_info_cnt == 3) {
4197 /* Antenna config to set 0x765 = 0x0 (GNT_BT control by
4198 * PTA) after initial
4199 */
4200 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4201 "[BTCoex], Set GNT_BT control by PTA\n");
4202 btc8821a2ant_set_ant_path(btcoexist,
4203 BTC_ANT_WIFI_AT_MAIN, false, false);
4204 }
4205 }
4206
4207 if (btcoexist->auto_report_2ant) {
4208 btc8821a2ant_query_bt_info(btcoexist);
4209 } else {
4210 btc8821a2ant_monitor_bt_ctr(btcoexist);
4211 btc8821a2ant_monitor_wifi_ctr(btcoexist);
4212
4213 if (btc8821a2ant_is_wifi_status_changed(btcoexist) ||
4214 coex_dm->auto_tdma_adjust)
4215 btc8821a2ant_run_coexist_mechanism(btcoexist);
4216 }
4217 }
Linux with added FPC-III support