?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[linux/fpc-iii.git] / drivers / net / wireless / realtek / rtlwifi / btcoexist / halbtc8192e2ant.c
blob451456835f8791283bd854703454136b0c1fd8b8
1 /******************************************************************************
2 *
3 * Copyright(c) 2012 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * The full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
16 *
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
21 *
22 * Larry Finger <Larry.Finger@lwfinger.net>
23 *
24 *****************************************************************************/
25 /**************************************************************
26 * Description:
27 *
28 * This file is for RTL8192E Co-exist mechanism
29 *
30 * History
31 * 2012/11/15 Cosa first check in.
32 *
33 **************************************************************/
34
35 /**************************************************************
36 * include files
37 **************************************************************/
38 #include "halbt_precomp.h"
39 /**************************************************************
40 * Global variables, these are static variables
41 **************************************************************/
42 static struct coex_dm_8192e_2ant glcoex_dm_8192e_2ant;
43 static struct coex_dm_8192e_2ant *coex_dm = &glcoex_dm_8192e_2ant;
44 static struct coex_sta_8192e_2ant glcoex_sta_8192e_2ant;
45 static struct coex_sta_8192e_2ant *coex_sta = &glcoex_sta_8192e_2ant;
46
47 static const char *const GLBtInfoSrc8192e2Ant[] = {
48 "BT Info[wifi fw]",
49 "BT Info[bt rsp]",
50 "BT Info[bt auto report]",
51 };
52
53 static u32 glcoex_ver_date_8192e_2ant = 20130902;
54 static u32 glcoex_ver_8192e_2ant = 0x34;
55
56 /**************************************************************
57 * local function proto type if needed
58 **************************************************************/
59 /**************************************************************
60 * local function start with halbtc8192e2ant_
61 **************************************************************/
62 static u8 halbtc8192e2ant_btrssi_state(u8 level_num, u8 rssi_thresh,
63 u8 rssi_thresh1)
64 {
65 int btrssi = 0;
66 u8 btrssi_state = coex_sta->pre_bt_rssi_state;
67
68 btrssi = coex_sta->bt_rssi;
69
70 if (level_num == 2) {
71 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
72 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
73 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
74 "BT Rssi pre state = LOW\n");
75 if (btrssi >= (rssi_thresh +
76 BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
77 btrssi_state = BTC_RSSI_STATE_HIGH;
78 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
79 "BT Rssi state switch to High\n");
80 } else {
81 btrssi_state = BTC_RSSI_STATE_STAY_LOW;
82 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
83 "BT Rssi state stay at Low\n");
84 }
85 } else {
86 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
87 "BT Rssi pre state = HIGH\n");
88 if (btrssi < rssi_thresh) {
89 btrssi_state = BTC_RSSI_STATE_LOW;
90 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
91 "BT Rssi state switch to Low\n");
92 } else {
93 btrssi_state = BTC_RSSI_STATE_STAY_HIGH;
94 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
95 "BT Rssi state stay at High\n");
96 }
97 }
98 } else if (level_num == 3) {
99 if (rssi_thresh > rssi_thresh1) {
100 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
101 "BT Rssi thresh error!!\n");
102 return coex_sta->pre_bt_rssi_state;
103 }
104
105 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
106 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
107 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
108 "BT Rssi pre state = LOW\n");
109 if (btrssi >= (rssi_thresh +
110 BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
111 btrssi_state = BTC_RSSI_STATE_MEDIUM;
112 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
113 "BT Rssi state switch to Medium\n");
114 } else {
115 btrssi_state = BTC_RSSI_STATE_STAY_LOW;
116 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
117 "BT Rssi state stay at Low\n");
118 }
119 } else if ((coex_sta->pre_bt_rssi_state ==
120 BTC_RSSI_STATE_MEDIUM) ||
121 (coex_sta->pre_bt_rssi_state ==
122 BTC_RSSI_STATE_STAY_MEDIUM)) {
123 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
124 "[BTCoex], BT Rssi pre state = MEDIUM\n");
125 if (btrssi >= (rssi_thresh1 +
126 BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
127 btrssi_state = BTC_RSSI_STATE_HIGH;
128 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
129 "BT Rssi state switch to High\n");
130 } else if (btrssi < rssi_thresh) {
131 btrssi_state = BTC_RSSI_STATE_LOW;
132 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
133 "BT Rssi state switch to Low\n");
134 } else {
135 btrssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
136 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
137 "BT Rssi state stay at Medium\n");
138 }
139 } else {
140 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
141 "BT Rssi pre state = HIGH\n");
142 if (btrssi < rssi_thresh1) {
143 btrssi_state = BTC_RSSI_STATE_MEDIUM;
144 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
145 "BT Rssi state switch to Medium\n");
146 } else {
147 btrssi_state = BTC_RSSI_STATE_STAY_HIGH;
148 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
149 "BT Rssi state stay at High\n");
150 }
151 }
152 }
153
154 coex_sta->pre_bt_rssi_state = btrssi_state;
155
156 return btrssi_state;
157 }
158
159 static u8 halbtc8192e2ant_wifirssi_state(struct btc_coexist *btcoexist,
160 u8 index, u8 level_num, u8 rssi_thresh,
161 u8 rssi_thresh1)
162 {
163 int wifirssi = 0;
164 u8 wifirssi_state = coex_sta->pre_wifi_rssi_state[index];
165
166 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifirssi);
167
168 if (level_num == 2) {
169 if ((coex_sta->pre_wifi_rssi_state[index] ==
170 BTC_RSSI_STATE_LOW) ||
171 (coex_sta->pre_wifi_rssi_state[index] ==
172 BTC_RSSI_STATE_STAY_LOW)) {
173 if (wifirssi >= (rssi_thresh +
174 BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
175 wifirssi_state = BTC_RSSI_STATE_HIGH;
176 BTC_PRINT(BTC_MSG_ALGORITHM,
177 ALGO_WIFI_RSSI_STATE,
178 "wifi RSSI state switch to High\n");
179 } else {
180 wifirssi_state = BTC_RSSI_STATE_STAY_LOW;
181 BTC_PRINT(BTC_MSG_ALGORITHM,
182 ALGO_WIFI_RSSI_STATE,
183 "wifi RSSI state stay at Low\n");
184 }
185 } else {
186 if (wifirssi < rssi_thresh) {
187 wifirssi_state = BTC_RSSI_STATE_LOW;
188 BTC_PRINT(BTC_MSG_ALGORITHM,
189 ALGO_WIFI_RSSI_STATE,
190 "wifi RSSI state switch to Low\n");
191 } else {
192 wifirssi_state = BTC_RSSI_STATE_STAY_HIGH;
193 BTC_PRINT(BTC_MSG_ALGORITHM,
194 ALGO_WIFI_RSSI_STATE,
195 "wifi RSSI state stay at High\n");
196 }
197 }
198 } else if (level_num == 3) {
199 if (rssi_thresh > rssi_thresh1) {
200 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
201 "wifi RSSI thresh error!!\n");
202 return coex_sta->pre_wifi_rssi_state[index];
203 }
204
205 if ((coex_sta->pre_wifi_rssi_state[index] ==
206 BTC_RSSI_STATE_LOW) ||
207 (coex_sta->pre_wifi_rssi_state[index] ==
208 BTC_RSSI_STATE_STAY_LOW)) {
209 if (wifirssi >= (rssi_thresh +
210 BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
211 wifirssi_state = BTC_RSSI_STATE_MEDIUM;
212 BTC_PRINT(BTC_MSG_ALGORITHM,
213 ALGO_WIFI_RSSI_STATE,
214 "wifi RSSI state switch to Medium\n");
215 } else {
216 wifirssi_state = BTC_RSSI_STATE_STAY_LOW;
217 BTC_PRINT(BTC_MSG_ALGORITHM,
218 ALGO_WIFI_RSSI_STATE,
219 "wifi RSSI state stay at Low\n");
220 }
221 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
222 BTC_RSSI_STATE_MEDIUM) ||
223 (coex_sta->pre_wifi_rssi_state[index] ==
224 BTC_RSSI_STATE_STAY_MEDIUM)) {
225 if (wifirssi >= (rssi_thresh1 +
226 BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
227 wifirssi_state = BTC_RSSI_STATE_HIGH;
228 BTC_PRINT(BTC_MSG_ALGORITHM,
229 ALGO_WIFI_RSSI_STATE,
230 "wifi RSSI state switch to High\n");
231 } else if (wifirssi < rssi_thresh) {
232 wifirssi_state = BTC_RSSI_STATE_LOW;
233 BTC_PRINT(BTC_MSG_ALGORITHM,
234 ALGO_WIFI_RSSI_STATE,
235 "wifi RSSI state switch to Low\n");
236 } else {
237 wifirssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
238 BTC_PRINT(BTC_MSG_ALGORITHM,
239 ALGO_WIFI_RSSI_STATE,
240 "wifi RSSI state stay at Medium\n");
241 }
242 } else {
243 if (wifirssi < rssi_thresh1) {
244 wifirssi_state = BTC_RSSI_STATE_MEDIUM;
245 BTC_PRINT(BTC_MSG_ALGORITHM,
246 ALGO_WIFI_RSSI_STATE,
247 "wifi RSSI state switch to Medium\n");
248 } else {
249 wifirssi_state = BTC_RSSI_STATE_STAY_HIGH;
250 BTC_PRINT(BTC_MSG_ALGORITHM,
251 ALGO_WIFI_RSSI_STATE,
252 "wifi RSSI state stay at High\n");
253 }
254 }
255 }
256
257 coex_sta->pre_wifi_rssi_state[index] = wifirssi_state;
258
259 return wifirssi_state;
260 }
261
262 static void btc8192e2ant_monitor_bt_enable_dis(struct btc_coexist *btcoexist)
263 {
264 static bool pre_bt_disabled;
265 static u32 bt_disable_cnt;
266 bool bt_active = true, bt_disabled = false;
267
268 /* This function check if bt is disabled */
269
270 if (coex_sta->high_priority_tx == 0 &&
271 coex_sta->high_priority_rx == 0 &&
272 coex_sta->low_priority_tx == 0 &&
273 coex_sta->low_priority_rx == 0)
274 bt_active = false;
275
276 if (coex_sta->high_priority_tx == 0xffff &&
277 coex_sta->high_priority_rx == 0xffff &&
278 coex_sta->low_priority_tx == 0xffff &&
279 coex_sta->low_priority_rx == 0xffff)
280 bt_active = false;
281
282 if (bt_active) {
283 bt_disable_cnt = 0;
284 bt_disabled = false;
285 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
286 &bt_disabled);
287 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
288 "[BTCoex], BT is enabled !!\n");
289 } else {
290 bt_disable_cnt++;
291 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
292 "[BTCoex], bt all counters = 0, %d times!!\n",
293 bt_disable_cnt);
294 if (bt_disable_cnt >= 2) {
295 bt_disabled = true;
296 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
297 &bt_disabled);
298 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
299 "[BTCoex], BT is disabled !!\n");
300 }
301 }
302 if (pre_bt_disabled != bt_disabled) {
303 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
304 "[BTCoex], BT is from %s to %s!!\n",
305 (pre_bt_disabled ? "disabled" : "enabled"),
306 (bt_disabled ? "disabled" : "enabled"));
307 pre_bt_disabled = bt_disabled;
308 }
309 }
310
311 static u32 halbtc8192e2ant_decidera_mask(struct btc_coexist *btcoexist,
312 u8 sstype, u32 ra_masktype)
313 {
314 u32 disra_mask = 0x0;
315
316 switch (ra_masktype) {
317 case 0: /* normal mode */
318 if (sstype == 2)
319 disra_mask = 0x0; /* enable 2ss */
320 else
321 disra_mask = 0xfff00000;/* disable 2ss */
322 break;
323 case 1: /* disable cck 1/2 */
324 if (sstype == 2)
325 disra_mask = 0x00000003;/* enable 2ss */
326 else
327 disra_mask = 0xfff00003;/* disable 2ss */
328 break;
329 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
330 if (sstype == 2)
331 disra_mask = 0x0001f1f7;/* enable 2ss */
332 else
333 disra_mask = 0xfff1f1f7;/* disable 2ss */
334 break;
335 default:
336 break;
337 }
338
339 return disra_mask;
340 }
341
342 static void halbtc8192e2ant_Updatera_mask(struct btc_coexist *btcoexist,
343 bool force_exec, u32 dis_ratemask)
344 {
345 coex_dm->curra_mask = dis_ratemask;
346
347 if (force_exec || (coex_dm->prera_mask != coex_dm->curra_mask))
348 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_ra_mask,
349 &coex_dm->curra_mask);
350 coex_dm->prera_mask = coex_dm->curra_mask;
351 }
352
353 static void btc8192e2ant_autorate_fallback_retry(struct btc_coexist *btcoexist,
354 bool force_exec, u8 type)
355 {
356 bool wifi_under_bmode = false;
357
358 coex_dm->cur_arfrtype = type;
359
360 if (force_exec || (coex_dm->pre_arfrtype != coex_dm->cur_arfrtype)) {
361 switch (coex_dm->cur_arfrtype) {
362 case 0: /* normal mode */
363 btcoexist->btc_write_4byte(btcoexist, 0x430,
364 coex_dm->backup_arfr_cnt1);
365 btcoexist->btc_write_4byte(btcoexist, 0x434,
366 coex_dm->backup_arfr_cnt2);
367 break;
368 case 1:
369 btcoexist->btc_get(btcoexist,
370 BTC_GET_BL_WIFI_UNDER_B_MODE,
371 &wifi_under_bmode);
372 if (wifi_under_bmode) {
373 btcoexist->btc_write_4byte(btcoexist, 0x430,
374 0x0);
375 btcoexist->btc_write_4byte(btcoexist, 0x434,
376 0x01010101);
377 } else {
378 btcoexist->btc_write_4byte(btcoexist, 0x430,
379 0x0);
380 btcoexist->btc_write_4byte(btcoexist, 0x434,
381 0x04030201);
382 }
383 break;
384 default:
385 break;
386 }
387 }
388
389 coex_dm->pre_arfrtype = coex_dm->cur_arfrtype;
390 }
391
392 static void halbtc8192e2ant_retrylimit(struct btc_coexist *btcoexist,
393 bool force_exec, u8 type)
394 {
395 coex_dm->cur_retrylimit_type = type;
396
397 if (force_exec || (coex_dm->pre_retrylimit_type !=
398 coex_dm->cur_retrylimit_type)) {
399 switch (coex_dm->cur_retrylimit_type) {
400 case 0: /* normal mode */
401 btcoexist->btc_write_2byte(btcoexist, 0x42a,
402 coex_dm->backup_retrylimit);
403 break;
404 case 1: /* retry limit = 8 */
405 btcoexist->btc_write_2byte(btcoexist, 0x42a,
406 0x0808);
407 break;
408 default:
409 break;
410 }
411 }
412
413 coex_dm->pre_retrylimit_type = coex_dm->cur_retrylimit_type;
414 }
415
416 static void halbtc8192e2ant_ampdu_maxtime(struct btc_coexist *btcoexist,
417 bool force_exec, u8 type)
418 {
419 coex_dm->cur_ampdutime_type = type;
420
421 if (force_exec || (coex_dm->pre_ampdutime_type !=
422 coex_dm->cur_ampdutime_type)) {
423 switch (coex_dm->cur_ampdutime_type) {
424 case 0: /* normal mode */
425 btcoexist->btc_write_1byte(btcoexist, 0x456,
426 coex_dm->backup_ampdu_maxtime);
427 break;
428 case 1: /* AMPDU timw = 0x38 * 32us */
429 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
430 break;
431 default:
432 break;
433 }
434 }
435
436 coex_dm->pre_ampdutime_type = coex_dm->cur_ampdutime_type;
437 }
438
439 static void halbtc8192e2ant_limited_tx(struct btc_coexist *btcoexist,
440 bool force_exec, u8 ra_masktype,
441 u8 arfr_type, u8 retrylimit_type,
442 u8 ampdutime_type)
443 {
444 u32 disra_mask = 0x0;
445
446 coex_dm->curra_masktype = ra_masktype;
447 disra_mask = halbtc8192e2ant_decidera_mask(btcoexist,
448 coex_dm->cur_sstype,
449 ra_masktype);
450 halbtc8192e2ant_Updatera_mask(btcoexist, force_exec, disra_mask);
451 btc8192e2ant_autorate_fallback_retry(btcoexist, force_exec, arfr_type);
452 halbtc8192e2ant_retrylimit(btcoexist, force_exec, retrylimit_type);
453 halbtc8192e2ant_ampdu_maxtime(btcoexist, force_exec, ampdutime_type);
454 }
455
456 static void halbtc8192e2ant_limited_rx(struct btc_coexist *btcoexist,
457 bool force_exec, bool rej_ap_agg_pkt,
458 bool bt_ctrl_agg_buf_size,
459 u8 agg_buf_size)
460 {
461 bool reject_rx_agg = rej_ap_agg_pkt;
462 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
463 u8 rx_agg_size = agg_buf_size;
464
465 /*********************************************
466 * Rx Aggregation related setting
467 *********************************************/
468 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
469 &reject_rx_agg);
470 /* decide BT control aggregation buf size or not */
471 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
472 &bt_ctrl_rx_agg_size);
473 /* aggregation buf size, only work
474 * when BT control Rx aggregation size.
475 */
476 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
477 /* real update aggregation setting */
478 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
479 }
480
481 static void halbtc8192e2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
482 {
483 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
484 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
485
486 reg_hp_txrx = 0x770;
487 reg_lp_txrx = 0x774;
488
489 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
490 reg_hp_tx = u32tmp & MASKLWORD;
491 reg_hp_rx = (u32tmp & MASKHWORD)>>16;
492
493 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
494 reg_lp_tx = u32tmp & MASKLWORD;
495 reg_lp_rx = (u32tmp & MASKHWORD)>>16;
496
497 coex_sta->high_priority_tx = reg_hp_tx;
498 coex_sta->high_priority_rx = reg_hp_rx;
499 coex_sta->low_priority_tx = reg_lp_tx;
500 coex_sta->low_priority_rx = reg_lp_rx;
501
502 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
503 "[BTCoex] High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
504 reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
505 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
506 "[BTCoex] Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
507 reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
508
509 /* reset counter */
510 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
511 }
512
513 static void halbtc8192e2ant_querybt_info(struct btc_coexist *btcoexist)
514 {
515 u8 h2c_parameter[1] = {0};
516
517 coex_sta->c2h_bt_info_req_sent = true;
518
519 h2c_parameter[0] |= BIT0; /* trigger */
520
521 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
522 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
523 h2c_parameter[0]);
524
525 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
526 }
527
528 static void halbtc8192e2ant_update_btlink_info(struct btc_coexist *btcoexist)
529 {
530 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
531 bool bt_hson = false;
532
533 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hson);
534
535 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
536 bt_link_info->sco_exist = coex_sta->sco_exist;
537 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
538 bt_link_info->pan_exist = coex_sta->pan_exist;
539 bt_link_info->hid_exist = coex_sta->hid_exist;
540
541 /* work around for HS mode. */
542 if (bt_hson) {
543 bt_link_info->pan_exist = true;
544 bt_link_info->bt_link_exist = true;
545 }
546
547 /* check if Sco only */
548 if (bt_link_info->sco_exist &&
549 !bt_link_info->a2dp_exist &&
550 !bt_link_info->pan_exist &&
551 !bt_link_info->hid_exist)
552 bt_link_info->sco_only = true;
553 else
554 bt_link_info->sco_only = false;
555
556 /* check if A2dp only */
557 if (!bt_link_info->sco_exist &&
558 bt_link_info->a2dp_exist &&
559 !bt_link_info->pan_exist &&
560 !bt_link_info->hid_exist)
561 bt_link_info->a2dp_only = true;
562 else
563 bt_link_info->a2dp_only = false;
564
565 /* check if Pan only */
566 if (!bt_link_info->sco_exist &&
567 !bt_link_info->a2dp_exist &&
568 bt_link_info->pan_exist &&
569 !bt_link_info->hid_exist)
570 bt_link_info->pan_only = true;
571 else
572 bt_link_info->pan_only = false;
573
574 /* check if Hid only */
575 if (!bt_link_info->sco_exist &&
576 !bt_link_info->a2dp_exist &&
577 !bt_link_info->pan_exist &&
578 bt_link_info->hid_exist)
579 bt_link_info->hid_only = true;
580 else
581 bt_link_info->hid_only = false;
582 }
583
584 static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
585 {
586 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
587 struct btc_stack_info *stack_info = &btcoexist->stack_info;
588 bool bt_hson = false;
589 u8 algorithm = BT_8192E_2ANT_COEX_ALGO_UNDEFINED;
590 u8 numdiffprofile = 0;
591
592 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hson);
593
594 if (!bt_link_info->bt_link_exist) {
595 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
596 "No BT link exists!!!\n");
597 return algorithm;
598 }
599
600 if (bt_link_info->sco_exist)
601 numdiffprofile++;
602 if (bt_link_info->hid_exist)
603 numdiffprofile++;
604 if (bt_link_info->pan_exist)
605 numdiffprofile++;
606 if (bt_link_info->a2dp_exist)
607 numdiffprofile++;
608
609 if (numdiffprofile == 1) {
610 if (bt_link_info->sco_exist) {
611 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
612 "SCO only\n");
613 algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
614 } else {
615 if (bt_link_info->hid_exist) {
616 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
617 "HID only\n");
618 algorithm = BT_8192E_2ANT_COEX_ALGO_HID;
619 } else if (bt_link_info->a2dp_exist) {
620 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
621 "A2DP only\n");
622 algorithm = BT_8192E_2ANT_COEX_ALGO_A2DP;
623 } else if (bt_link_info->pan_exist) {
624 if (bt_hson) {
625 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
626 "PAN(HS) only\n");
627 algorithm =
628 BT_8192E_2ANT_COEX_ALGO_PANHS;
629 } else {
630 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
631 "PAN(EDR) only\n");
632 algorithm =
633 BT_8192E_2ANT_COEX_ALGO_PANEDR;
634 }
635 }
636 }
637 } else if (numdiffprofile == 2) {
638 if (bt_link_info->sco_exist) {
639 if (bt_link_info->hid_exist) {
640 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
641 "SCO + HID\n");
642 algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
643 } else if (bt_link_info->a2dp_exist) {
644 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
645 "SCO + A2DP ==> SCO\n");
646 algorithm = BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
647 } else if (bt_link_info->pan_exist) {
648 if (bt_hson) {
649 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
650 "SCO + PAN(HS)\n");
651 algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
652 } else {
653 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
654 "SCO + PAN(EDR)\n");
655 algorithm =
656 BT_8192E_2ANT_COEX_ALGO_SCO_PAN;
657 }
658 }
659 } else {
660 if (bt_link_info->hid_exist &&
661 bt_link_info->a2dp_exist) {
662 if (stack_info->num_of_hid >= 2) {
663 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
664 "HID*2 + A2DP\n");
665 algorithm =
666 BT_8192E_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
667 } else {
668 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
669 "HID + A2DP\n");
670 algorithm =
671 BT_8192E_2ANT_COEX_ALGO_HID_A2DP;
672 }
673 } else if (bt_link_info->hid_exist &&
674 bt_link_info->pan_exist) {
675 if (bt_hson) {
676 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
677 "HID + PAN(HS)\n");
678 algorithm = BT_8192E_2ANT_COEX_ALGO_HID;
679 } else {
680 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
681 "HID + PAN(EDR)\n");
682 algorithm =
683 BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
684 }
685 } else if (bt_link_info->pan_exist &&
686 bt_link_info->a2dp_exist) {
687 if (bt_hson) {
688 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
689 "A2DP + PAN(HS)\n");
690 algorithm =
691 BT_8192E_2ANT_COEX_ALGO_A2DP_PANHS;
692 } else {
693 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
694 "A2DP + PAN(EDR)\n");
695 algorithm =
696 BT_8192E_2ANT_COEX_ALGO_PANEDR_A2DP;
697 }
698 }
699 }
700 } else if (numdiffprofile == 3) {
701 if (bt_link_info->sco_exist) {
702 if (bt_link_info->hid_exist &&
703 bt_link_info->a2dp_exist) {
704 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
705 "SCO + HID + A2DP ==> HID\n");
706 algorithm = BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
707 } else if (bt_link_info->hid_exist &&
708 bt_link_info->pan_exist) {
709 if (bt_hson) {
710 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
711 "SCO + HID + PAN(HS)\n");
712 algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
713 } else {
714 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
715 "SCO + HID + PAN(EDR)\n");
716 algorithm =
717 BT_8192E_2ANT_COEX_ALGO_SCO_PAN;
718 }
719 } else if (bt_link_info->pan_exist &&
720 bt_link_info->a2dp_exist) {
721 if (bt_hson) {
722 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
723 "SCO + A2DP + PAN(HS)\n");
724 algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
725 } else {
726 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
727 "SCO + A2DP + PAN(EDR)\n");
728 algorithm =
729 BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
730 }
731 }
732 } else {
733 if (bt_link_info->hid_exist &&
734 bt_link_info->pan_exist &&
735 bt_link_info->a2dp_exist) {
736 if (bt_hson) {
737 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
738 "HID + A2DP + PAN(HS)\n");
739 algorithm =
740 BT_8192E_2ANT_COEX_ALGO_HID_A2DP;
741 } else {
742 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
743 "HID + A2DP + PAN(EDR)\n");
744 algorithm =
745 BT_8192E_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
746 }
747 }
748 }
749 } else if (numdiffprofile >= 3) {
750 if (bt_link_info->sco_exist) {
751 if (bt_link_info->hid_exist &&
752 bt_link_info->pan_exist &&
753 bt_link_info->a2dp_exist) {
754 if (bt_hson) {
755 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
756 "ErrorSCO+HID+A2DP+PAN(HS)\n");
757
758 } else {
759 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
760 "SCO+HID+A2DP+PAN(EDR)\n");
761 algorithm =
762 BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
763 }
764 }
765 }
766 }
767
768 return algorithm;
769 }
770
771 static void halbtc8192e2ant_setfw_dac_swinglevel(struct btc_coexist *btcoexist,
772 u8 dac_swinglvl)
773 {
774 u8 h2c_parameter[1] = {0};
775
776 /* There are several type of dacswing
777 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
778 */
779 h2c_parameter[0] = dac_swinglvl;
780
781 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
782 "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swinglvl);
783 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
784 "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
785
786 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
787 }
788
789 static void halbtc8192e2ant_set_fwdec_btpwr(struct btc_coexist *btcoexist,
790 u8 dec_btpwr_lvl)
791 {
792 u8 h2c_parameter[1] = {0};
793
794 h2c_parameter[0] = dec_btpwr_lvl;
795
796 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
797 "[BTCoex] decrease Bt Power level = %d, FW write 0x62 = 0x%x\n",
798 dec_btpwr_lvl, h2c_parameter[0]);
799
800 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
801 }
802
803 static void halbtc8192e2ant_dec_btpwr(struct btc_coexist *btcoexist,
804 bool force_exec, u8 dec_btpwr_lvl)
805 {
806 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
807 "[BTCoex], %s Dec BT power level = %d\n",
808 (force_exec ? "force to" : ""), dec_btpwr_lvl);
809 coex_dm->cur_dec_bt_pwr = dec_btpwr_lvl;
810
811 if (!force_exec) {
812 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
813 "[BTCoex], preBtDecPwrLvl=%d, curBtDecPwrLvl=%d\n",
814 coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
815 }
816 halbtc8192e2ant_set_fwdec_btpwr(btcoexist, coex_dm->cur_dec_bt_pwr);
817
818 coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr;
819 }
820
821 static void halbtc8192e2ant_set_bt_autoreport(struct btc_coexist *btcoexist,
822 bool enable_autoreport)
823 {
824 u8 h2c_parameter[1] = {0};
825
826 h2c_parameter[0] = 0;
827
828 if (enable_autoreport)
829 h2c_parameter[0] |= BIT0;
830
831 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
832 "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
833 (enable_autoreport ? "Enabled!!" : "Disabled!!"),
834 h2c_parameter[0]);
835
836 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
837 }
838
839 static void halbtc8192e2ant_bt_autoreport(struct btc_coexist *btcoexist,
840 bool force_exec,
841 bool enable_autoreport)
842 {
843 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
844 "[BTCoex], %s BT Auto report = %s\n",
845 (force_exec ? "force to" : ""),
846 ((enable_autoreport) ? "Enabled" : "Disabled"));
847 coex_dm->cur_bt_auto_report = enable_autoreport;
848
849 if (!force_exec) {
850 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
851 "[BTCoex] bPreBtAutoReport=%d, bCurBtAutoReport=%d\n",
852 coex_dm->pre_bt_auto_report,
853 coex_dm->cur_bt_auto_report);
854
855 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
856 return;
857 }
858 halbtc8192e2ant_set_bt_autoreport(btcoexist,
859 coex_dm->cur_bt_auto_report);
860
861 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
862 }
863
864 static void halbtc8192e2ant_fw_dac_swinglvl(struct btc_coexist *btcoexist,
865 bool force_exec, u8 fw_dac_swinglvl)
866 {
867 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
868 "[BTCoex], %s set FW Dac Swing level = %d\n",
869 (force_exec ? "force to" : ""), fw_dac_swinglvl);
870 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swinglvl;
871
872 if (!force_exec) {
873 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
874 "[BTCoex] preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
875 coex_dm->pre_fw_dac_swing_lvl,
876 coex_dm->cur_fw_dac_swing_lvl);
877
878 if (coex_dm->pre_fw_dac_swing_lvl ==
879 coex_dm->cur_fw_dac_swing_lvl)
880 return;
881 }
882
883 halbtc8192e2ant_setfw_dac_swinglevel(btcoexist,
884 coex_dm->cur_fw_dac_swing_lvl);
885
886 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
887 }
888
889 static void btc8192e2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
890 bool rx_rf_shrink_on)
891 {
892 if (rx_rf_shrink_on) {
893 /* Shrink RF Rx LPF corner */
894 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
895 "[BTCoex], Shrink RF Rx LPF corner!!\n");
896 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
897 0xfffff, 0xffffc);
898 } else {
899 /* Resume RF Rx LPF corner
900 * After initialized, we can use coex_dm->btRf0x1eBackup
901 */
902 if (btcoexist->initilized) {
903 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
904 "[BTCoex], Resume RF Rx LPF corner!!\n");
905 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
906 0xfffff,
907 coex_dm->bt_rf0x1e_backup);
908 }
909 }
910 }
911
912 static void halbtc8192e2ant_rf_shrink(struct btc_coexist *btcoexist,
913 bool force_exec, bool rx_rf_shrink_on)
914 {
915 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
916 "[BTCoex], %s turn Rx RF Shrink = %s\n",
917 (force_exec ? "force to" : ""),
918 ((rx_rf_shrink_on) ? "ON" : "OFF"));
919 coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
920
921 if (!force_exec) {
922 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
923 "[BTCoex]bPreRfRxLpfShrink=%d,bCurRfRxLpfShrink=%d\n",
924 coex_dm->pre_rf_rx_lpf_shrink,
925 coex_dm->cur_rf_rx_lpf_shrink);
926
927 if (coex_dm->pre_rf_rx_lpf_shrink ==
928 coex_dm->cur_rf_rx_lpf_shrink)
929 return;
930 }
931 btc8192e2ant_set_sw_rf_rx_lpf_corner(btcoexist,
932 coex_dm->cur_rf_rx_lpf_shrink);
933
934 coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink;
935 }
936
937 static void halbtc8192e2ant_set_dac_swingreg(struct btc_coexist *btcoexist,
938 u32 level)
939 {
940 u8 val = (u8)level;
941
942 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
943 "[BTCoex], Write SwDacSwing = 0x%x\n", level);
944 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
945 }
946
947 static void btc8192e2ant_setsw_full_swing(struct btc_coexist *btcoexist,
948 bool sw_dac_swingon,
949 u32 sw_dac_swinglvl)
950 {
951 if (sw_dac_swingon)
952 halbtc8192e2ant_set_dac_swingreg(btcoexist, sw_dac_swinglvl);
953 else
954 halbtc8192e2ant_set_dac_swingreg(btcoexist, 0x18);
955 }
956
957 static void halbtc8192e2ant_DacSwing(struct btc_coexist *btcoexist,
958 bool force_exec, bool dac_swingon,
959 u32 dac_swinglvl)
960 {
961 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
962 "[BTCoex], %s turn DacSwing=%s, dac_swinglvl = 0x%x\n",
963 (force_exec ? "force to" : ""),
964 ((dac_swingon) ? "ON" : "OFF"), dac_swinglvl);
965 coex_dm->cur_dac_swing_on = dac_swingon;
966 coex_dm->cur_dac_swing_lvl = dac_swinglvl;
967
968 if (!force_exec) {
969 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
970 "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl = 0x%x, ",
971 coex_dm->pre_dac_swing_on,
972 coex_dm->pre_dac_swing_lvl);
973 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
974 "bCurDacSwingOn=%d, curDacSwingLvl = 0x%x\n",
975 coex_dm->cur_dac_swing_on,
976 coex_dm->cur_dac_swing_lvl);
977
978 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
979 (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
980 return;
981 }
982 mdelay(30);
983 btc8192e2ant_setsw_full_swing(btcoexist, dac_swingon, dac_swinglvl);
984
985 coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
986 coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
987 }
988
989 static void halbtc8192e2ant_set_agc_table(struct btc_coexist *btcoexist,
990 bool agc_table_en)
991 {
992 /* BB AGC Gain Table */
993 if (agc_table_en) {
994 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
995 "[BTCoex], BB Agc Table On!\n");
996 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x0a1A0001);
997 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x091B0001);
998 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x081C0001);
999 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x071D0001);
1000 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x061E0001);
1001 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x051F0001);
1002 } else {
1003 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
1004 "[BTCoex], BB Agc Table Off!\n");
1005 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001);
1006 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001);
1007 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001);
1008 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa71D0001);
1009 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa61E0001);
1010 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa51F0001);
1011 }
1012 }
1013
1014 static void halbtc8192e2ant_AgcTable(struct btc_coexist *btcoexist,
1015 bool force_exec, bool agc_table_en)
1016 {
1017 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
1018 "[BTCoex], %s %s Agc Table\n",
1019 (force_exec ? "force to" : ""),
1020 ((agc_table_en) ? "Enable" : "Disable"));
1021 coex_dm->cur_agc_table_en = agc_table_en;
1022
1023 if (!force_exec) {
1024 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
1025 "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
1026 coex_dm->pre_agc_table_en, coex_dm->cur_agc_table_en);
1027
1028 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
1029 return;
1030 }
1031 halbtc8192e2ant_set_agc_table(btcoexist, agc_table_en);
1032
1033 coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en;
1034 }
1035
1036 static void halbtc8192e2ant_set_coex_table(struct btc_coexist *btcoexist,
1037 u32 val0x6c0, u32 val0x6c4,
1038 u32 val0x6c8, u8 val0x6cc)
1039 {
1040 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
1041 "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
1042 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
1043
1044 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
1045 "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
1046 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
1047
1048 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
1049 "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
1050 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
1051
1052 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
1053 "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
1054 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
1055 }
1056
1057 static void halbtc8192e2ant_coex_table(struct btc_coexist *btcoexist,
1058 bool force_exec,
1059 u32 val0x6c0, u32 val0x6c4,
1060 u32 val0x6c8, u8 val0x6cc)
1061 {
1062 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
1063 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, ",
1064 (force_exec ? "force to" : ""), val0x6c0);
1065 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
1066 "0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
1067 val0x6c4, val0x6c8, val0x6cc);
1068 coex_dm->cur_val0x6c0 = val0x6c0;
1069 coex_dm->cur_val0x6c4 = val0x6c4;
1070 coex_dm->cur_val0x6c8 = val0x6c8;
1071 coex_dm->cur_val0x6cc = val0x6cc;
1072
1073 if (!force_exec) {
1074 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
1075 "[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c4 = 0x%x, ",
1076 coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4);
1077 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
1078 "preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n",
1079 coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
1080 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
1081 "[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c4 = 0x%x,\n",
1082 coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4);
1083 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
1084 "curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n",
1085 coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
1086
1087 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1088 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1089 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1090 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1091 return;
1092 }
1093 halbtc8192e2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
1094 val0x6c8, val0x6cc);
1095
1096 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1097 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1098 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1099 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1100 }
1101
1102 static void btc8192e2ant_coex_tbl_w_type(struct btc_coexist *btcoexist,
1103 bool force_exec, u8 type)
1104 {
1105 switch (type) {
1106 case 0:
1107 halbtc8192e2ant_coex_table(btcoexist, force_exec, 0x55555555,
1108 0x5a5a5a5a, 0xffffff, 0x3);
1109 break;
1110 case 1:
1111 halbtc8192e2ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
1112 0x5a5a5a5a, 0xffffff, 0x3);
1113 break;
1114 case 2:
1115 halbtc8192e2ant_coex_table(btcoexist, force_exec, 0x55555555,
1116 0x5ffb5ffb, 0xffffff, 0x3);
1117 break;
1118 case 3:
1119 halbtc8192e2ant_coex_table(btcoexist, force_exec, 0xdfffdfff,
1120 0x5fdb5fdb, 0xffffff, 0x3);
1121 break;
1122 case 4:
1123 halbtc8192e2ant_coex_table(btcoexist, force_exec, 0xdfffdfff,
1124 0x5ffb5ffb, 0xffffff, 0x3);
1125 break;
1126 default:
1127 break;
1128 }
1129 }
1130
1131 static void halbtc8192e2ant_set_fw_ignore_wlanact(struct btc_coexist *btcoexist,
1132 bool enable)
1133 {
1134 u8 h2c_parameter[1] = {0};
1135
1136 if (enable)
1137 h2c_parameter[0] |= BIT0; /* function enable */
1138
1139 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
1140 "[BTCoex]set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
1141 h2c_parameter[0]);
1142
1143 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1144 }
1145
1146 static void halbtc8192e2ant_IgnoreWlanAct(struct btc_coexist *btcoexist,
1147 bool force_exec, bool enable)
1148 {
1149 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
1150 "[BTCoex], %s turn Ignore WlanAct %s\n",
1151 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1152 coex_dm->cur_ignore_wlan_act = enable;
1153
1154 if (!force_exec) {
1155 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1156 "[BTCoex], bPreIgnoreWlanAct = %d ",
1157 coex_dm->pre_ignore_wlan_act);
1158 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1159 "bCurIgnoreWlanAct = %d!!\n",
1160 coex_dm->cur_ignore_wlan_act);
1161
1162 if (coex_dm->pre_ignore_wlan_act ==
1163 coex_dm->cur_ignore_wlan_act)
1164 return;
1165 }
1166 halbtc8192e2ant_set_fw_ignore_wlanact(btcoexist, enable);
1167
1168 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1169 }
1170
1171 static void halbtc8192e2ant_SetFwPstdma(struct btc_coexist *btcoexist, u8 byte1,
1172 u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1173 {
1174 u8 h2c_parameter[5] = {0};
1175
1176 h2c_parameter[0] = byte1;
1177 h2c_parameter[1] = byte2;
1178 h2c_parameter[2] = byte3;
1179 h2c_parameter[3] = byte4;
1180 h2c_parameter[4] = byte5;
1181
1182 coex_dm->ps_tdma_para[0] = byte1;
1183 coex_dm->ps_tdma_para[1] = byte2;
1184 coex_dm->ps_tdma_para[2] = byte3;
1185 coex_dm->ps_tdma_para[3] = byte4;
1186 coex_dm->ps_tdma_para[4] = byte5;
1187
1188 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
1189 "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
1190 h2c_parameter[0],
1191 h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1192 h2c_parameter[3] << 8 | h2c_parameter[4]);
1193
1194 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1195 }
1196
1197 static void btc8192e2ant_sw_mec1(struct btc_coexist *btcoexist,
1198 bool shrink_rx_lpf, bool low_penalty_ra,
1199 bool limited_dig, bool btlan_constrain)
1200 {
1201 halbtc8192e2ant_rf_shrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf);
1202 }
1203
1204 static void btc8192e2ant_sw_mec2(struct btc_coexist *btcoexist,
1205 bool agc_table_shift, bool adc_backoff,
1206 bool sw_dac_swing, u32 dac_swinglvl)
1207 {
1208 halbtc8192e2ant_AgcTable(btcoexist, NORMAL_EXEC, agc_table_shift);
1209 halbtc8192e2ant_DacSwing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1210 dac_swinglvl);
1211 }
1212
1213 static void halbtc8192e2ant_ps_tdma(struct btc_coexist *btcoexist,
1214 bool force_exec, bool turn_on, u8 type)
1215 {
1216 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
1217 "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1218 (force_exec ? "force to" : ""),
1219 (turn_on ? "ON" : "OFF"), type);
1220 coex_dm->cur_ps_tdma_on = turn_on;
1221 coex_dm->cur_ps_tdma = type;
1222
1223 if (!force_exec) {
1224 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1225 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1226 coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1227 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1228 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1229 coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1230
1231 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1232 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1233 return;
1234 }
1235 if (turn_on) {
1236 switch (type) {
1237 case 1:
1238 default:
1239 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1a,
1240 0x1a, 0xe1, 0x90);
1241 break;
1242 case 2:
1243 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x12,
1244 0x12, 0xe1, 0x90);
1245 break;
1246 case 3:
1247 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1c,
1248 0x3, 0xf1, 0x90);
1249 break;
1250 case 4:
1251 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x10,
1252 0x3, 0xf1, 0x90);
1253 break;
1254 case 5:
1255 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1a,
1256 0x1a, 0x60, 0x90);
1257 break;
1258 case 6:
1259 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x12,
1260 0x12, 0x60, 0x90);
1261 break;
1262 case 7:
1263 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1c,
1264 0x3, 0x70, 0x90);
1265 break;
1266 case 8:
1267 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xa3, 0x10,
1268 0x3, 0x70, 0x90);
1269 break;
1270 case 9:
1271 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1a,
1272 0x1a, 0xe1, 0x10);
1273 break;
1274 case 10:
1275 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x12,
1276 0x12, 0xe1, 0x10);
1277 break;
1278 case 11:
1279 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1c,
1280 0x3, 0xf1, 0x10);
1281 break;
1282 case 12:
1283 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x10,
1284 0x3, 0xf1, 0x10);
1285 break;
1286 case 13:
1287 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1a,
1288 0x1a, 0xe0, 0x10);
1289 break;
1290 case 14:
1291 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x12,
1292 0x12, 0xe0, 0x10);
1293 break;
1294 case 15:
1295 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1c,
1296 0x3, 0xf0, 0x10);
1297 break;
1298 case 16:
1299 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x12,
1300 0x3, 0xf0, 0x10);
1301 break;
1302 case 17:
1303 halbtc8192e2ant_SetFwPstdma(btcoexist, 0x61, 0x20,
1304 0x03, 0x10, 0x10);
1305 break;
1306 case 18:
1307 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x5,
1308 0x5, 0xe1, 0x90);
1309 break;
1310 case 19:
1311 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x25,
1312 0x25, 0xe1, 0x90);
1313 break;
1314 case 20:
1315 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x25,
1316 0x25, 0x60, 0x90);
1317 break;
1318 case 21:
1319 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x15,
1320 0x03, 0x70, 0x90);
1321 break;
1322 case 71:
1323 halbtc8192e2ant_SetFwPstdma(btcoexist, 0xe3, 0x1a,
1324 0x1a, 0xe1, 0x90);
1325 break;
1326 }
1327 } else {
1328 /* disable PS tdma */
1329 switch (type) {
1330 default:
1331 case 0:
1332 halbtc8192e2ant_SetFwPstdma(btcoexist, 0x8, 0x0, 0x0,
1333 0x0, 0x0);
1334 btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x4);
1335 break;
1336 case 1:
1337 halbtc8192e2ant_SetFwPstdma(btcoexist, 0x0, 0x0, 0x0,
1338 0x8, 0x0);
1339 mdelay(5);
1340 btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x20);
1341 break;
1342 }
1343 }
1344
1345 /* update pre state */
1346 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1347 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1348 }
1349
1350 static void halbtc8192e2ant_set_switch_sstype(struct btc_coexist *btcoexist,
1351 u8 sstype)
1352 {
1353 u8 mimops = BTC_MIMO_PS_DYNAMIC;
1354 u32 disra_mask = 0x0;
1355
1356 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1357 "[BTCoex], REAL set SS Type = %d\n", sstype);
1358
1359 disra_mask = halbtc8192e2ant_decidera_mask(btcoexist, sstype,
1360 coex_dm->curra_masktype);
1361 halbtc8192e2ant_Updatera_mask(btcoexist, FORCE_EXEC, disra_mask);
1362
1363 if (sstype == 1) {
1364 halbtc8192e2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1365 /* switch ofdm path */
1366 btcoexist->btc_write_1byte(btcoexist, 0xc04, 0x11);
1367 btcoexist->btc_write_1byte(btcoexist, 0xd04, 0x1);
1368 btcoexist->btc_write_4byte(btcoexist, 0x90c, 0x81111111);
1369 /* switch cck patch */
1370 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xe77, 0x4, 0x1);
1371 btcoexist->btc_write_1byte(btcoexist, 0xa07, 0x81);
1372 mimops = BTC_MIMO_PS_STATIC;
1373 } else if (sstype == 2) {
1374 halbtc8192e2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
1375 btcoexist->btc_write_1byte(btcoexist, 0xc04, 0x33);
1376 btcoexist->btc_write_1byte(btcoexist, 0xd04, 0x3);
1377 btcoexist->btc_write_4byte(btcoexist, 0x90c, 0x81121313);
1378 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xe77, 0x4, 0x0);
1379 btcoexist->btc_write_1byte(btcoexist, 0xa07, 0x41);
1380 mimops = BTC_MIMO_PS_DYNAMIC;
1381 }
1382 /* set rx 1ss or 2ss */
1383 btcoexist->btc_set(btcoexist, BTC_SET_ACT_SEND_MIMO_PS, &mimops);
1384 }
1385
1386 static void halbtc8192e2ant_switch_sstype(struct btc_coexist *btcoexist,
1387 bool force_exec, u8 new_sstype)
1388 {
1389 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1390 "[BTCoex], %s Switch SS Type = %d\n",
1391 (force_exec ? "force to" : ""), new_sstype);
1392 coex_dm->cur_sstype = new_sstype;
1393
1394 if (!force_exec) {
1395 if (coex_dm->pre_sstype == coex_dm->cur_sstype)
1396 return;
1397 }
1398 halbtc8192e2ant_set_switch_sstype(btcoexist, coex_dm->cur_sstype);
1399
1400 coex_dm->pre_sstype = coex_dm->cur_sstype;
1401 }
1402
1403 static void halbtc8192e2ant_coex_alloff(struct btc_coexist *btcoexist)
1404 {
1405 /* fw all off */
1406 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1407 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
1408 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
1409
1410 /* sw all off */
1411 btc8192e2ant_sw_mec1(btcoexist, false, false, false, false);
1412 btc8192e2ant_sw_mec2(btcoexist, false, false, false, 0x18);
1413
1414 /* hw all off */
1415 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 0);
1416 }
1417
1418 static void halbtc8192e2ant_init_coex_dm(struct btc_coexist *btcoexist)
1419 {
1420 /* force to reset coex mechanism */
1421
1422 halbtc8192e2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1423 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, FORCE_EXEC, 6);
1424 halbtc8192e2ant_dec_btpwr(btcoexist, FORCE_EXEC, 0);
1425
1426 btc8192e2ant_coex_tbl_w_type(btcoexist, FORCE_EXEC, 0);
1427 halbtc8192e2ant_switch_sstype(btcoexist, FORCE_EXEC, 2);
1428
1429 btc8192e2ant_sw_mec1(btcoexist, false, false, false, false);
1430 btc8192e2ant_sw_mec2(btcoexist, false, false, false, 0x18);
1431 }
1432
1433 static void halbtc8192e2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1434 {
1435 bool low_pwr_disable = true;
1436
1437 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1438 &low_pwr_disable);
1439
1440 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
1441
1442 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 2);
1443 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1444 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
1445 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
1446
1447 btc8192e2ant_sw_mec1(btcoexist, false, false, false, false);
1448 btc8192e2ant_sw_mec2(btcoexist, false, false, false, 0x18);
1449 }
1450
1451 static bool halbtc8192e2ant_is_common_action(struct btc_coexist *btcoexist)
1452 {
1453 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1454 bool common = false, wifi_connected = false, wifi_busy = false;
1455 bool bt_hson = false, low_pwr_disable = false;
1456
1457 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hson);
1458 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1459 &wifi_connected);
1460 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1461
1462 if (bt_link_info->sco_exist || bt_link_info->hid_exist)
1463 halbtc8192e2ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 0, 0, 0);
1464 else
1465 halbtc8192e2ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1466
1467 if (!wifi_connected) {
1468 low_pwr_disable = false;
1469 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1470 &low_pwr_disable);
1471
1472 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1473 "[BTCoex], Wifi non-connected idle!!\n");
1474
1475 if ((BT_8192E_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1476 coex_dm->bt_status) ||
1477 (BT_8192E_2ANT_BT_STATUS_CONNECTED_IDLE ==
1478 coex_dm->bt_status)) {
1479 halbtc8192e2ant_switch_sstype(btcoexist,
1480 NORMAL_EXEC, 2);
1481 btc8192e2ant_coex_tbl_w_type(btcoexist,
1482 NORMAL_EXEC, 1);
1483 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1484 false, 0);
1485 } else {
1486 halbtc8192e2ant_switch_sstype(btcoexist,
1487 NORMAL_EXEC, 1);
1488 btc8192e2ant_coex_tbl_w_type(btcoexist,
1489 NORMAL_EXEC, 0);
1490 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1491 false, 1);
1492 }
1493
1494 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
1495 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
1496
1497 btc8192e2ant_sw_mec1(btcoexist, false, false, false, false);
1498 btc8192e2ant_sw_mec2(btcoexist, false, false, false, 0x18);
1499
1500 common = true;
1501 } else {
1502 if (BT_8192E_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1503 coex_dm->bt_status) {
1504 low_pwr_disable = false;
1505 btcoexist->btc_set(btcoexist,
1506 BTC_SET_ACT_DISABLE_LOW_POWER,
1507 &low_pwr_disable);
1508
1509 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1510 "Wifi connected + BT non connected-idle!!\n");
1511
1512 halbtc8192e2ant_switch_sstype(btcoexist,
1513 NORMAL_EXEC, 2);
1514 btc8192e2ant_coex_tbl_w_type(btcoexist,
1515 NORMAL_EXEC, 1);
1516 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1517 false, 0);
1518 halbtc8192e2ant_fw_dac_swinglvl(btcoexist,
1519 NORMAL_EXEC, 6);
1520 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
1521
1522 btc8192e2ant_sw_mec1(btcoexist, false, false,
1523 false, false);
1524 btc8192e2ant_sw_mec2(btcoexist, false, false,
1525 false, 0x18);
1526
1527 common = true;
1528 } else if (BT_8192E_2ANT_BT_STATUS_CONNECTED_IDLE ==
1529 coex_dm->bt_status) {
1530 low_pwr_disable = true;
1531 btcoexist->btc_set(btcoexist,
1532 BTC_SET_ACT_DISABLE_LOW_POWER,
1533 &low_pwr_disable);
1534
1535 if (bt_hson)
1536 return false;
1537 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1538 "Wifi connected + BT connected-idle!!\n");
1539
1540 halbtc8192e2ant_switch_sstype(btcoexist,
1541 NORMAL_EXEC, 2);
1542 btc8192e2ant_coex_tbl_w_type(btcoexist,
1543 NORMAL_EXEC, 1);
1544 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1545 false, 0);
1546 halbtc8192e2ant_fw_dac_swinglvl(btcoexist,
1547 NORMAL_EXEC, 6);
1548 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
1549
1550 btc8192e2ant_sw_mec1(btcoexist, true, false,
1551 false, false);
1552 btc8192e2ant_sw_mec2(btcoexist, false, false,
1553 false, 0x18);
1554
1555 common = true;
1556 } else {
1557 low_pwr_disable = true;
1558 btcoexist->btc_set(btcoexist,
1559 BTC_SET_ACT_DISABLE_LOW_POWER,
1560 &low_pwr_disable);
1561
1562 if (wifi_busy) {
1563 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1564 "Wifi Connected-Busy + BT Busy!!\n");
1565 common = false;
1566 } else {
1567 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1568 "Wifi Connected-Idle + BT Busy!!\n");
1569
1570 halbtc8192e2ant_switch_sstype(btcoexist,
1571 NORMAL_EXEC, 1);
1572 btc8192e2ant_coex_tbl_w_type(btcoexist,
1573 NORMAL_EXEC, 2);
1574 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1575 true, 21);
1576 halbtc8192e2ant_fw_dac_swinglvl(btcoexist,
1577 NORMAL_EXEC, 6);
1578 halbtc8192e2ant_dec_btpwr(btcoexist,
1579 NORMAL_EXEC, 0);
1580 btc8192e2ant_sw_mec1(btcoexist, false,
1581 false, false, false);
1582 btc8192e2ant_sw_mec2(btcoexist, false,
1583 false, false, 0x18);
1584 common = true;
1585 }
1586 }
1587 }
1588 return common;
1589 }
1590
1591 static void btc8192e_int1(struct btc_coexist *btcoexist, bool tx_pause,
1592 int result)
1593 {
1594 if (tx_pause) {
1595 BTC_PRINT(BTC_MSG_ALGORITHM,
1596 ALGO_TRACE_FW_DETAIL,
1597 "[BTCoex], TxPause = 1\n");
1598
1599 if (coex_dm->cur_ps_tdma == 71) {
1600 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1601 true, 5);
1602 coex_dm->tdma_adj_type = 5;
1603 } else if (coex_dm->cur_ps_tdma == 1) {
1604 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1605 true, 5);
1606 coex_dm->tdma_adj_type = 5;
1607 } else if (coex_dm->cur_ps_tdma == 2) {
1608 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1609 true, 6);
1610 coex_dm->tdma_adj_type = 6;
1611 } else if (coex_dm->cur_ps_tdma == 3) {
1612 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1613 true, 7);
1614 coex_dm->tdma_adj_type = 7;
1615 } else if (coex_dm->cur_ps_tdma == 4) {
1616 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1617 true, 8);
1618 coex_dm->tdma_adj_type = 8;
1619 }
1620 if (coex_dm->cur_ps_tdma == 9) {
1621 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1622 true, 13);
1623 coex_dm->tdma_adj_type = 13;
1624 } else if (coex_dm->cur_ps_tdma == 10) {
1625 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1626 true, 14);
1627 coex_dm->tdma_adj_type = 14;
1628 } else if (coex_dm->cur_ps_tdma == 11) {
1629 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1630 true, 15);
1631 coex_dm->tdma_adj_type = 15;
1632 } else if (coex_dm->cur_ps_tdma == 12) {
1633 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1634 true, 16);
1635 coex_dm->tdma_adj_type = 16;
1636 }
1637
1638 if (result == -1) {
1639 if (coex_dm->cur_ps_tdma == 5) {
1640 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1641 true, 6);
1642 coex_dm->tdma_adj_type = 6;
1643 } else if (coex_dm->cur_ps_tdma == 6) {
1644 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1645 true, 7);
1646 coex_dm->tdma_adj_type = 7;
1647 } else if (coex_dm->cur_ps_tdma == 7) {
1648 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1649 true, 8);
1650 coex_dm->tdma_adj_type = 8;
1651 } else if (coex_dm->cur_ps_tdma == 13) {
1652 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1653 true, 14);
1654 coex_dm->tdma_adj_type = 14;
1655 } else if (coex_dm->cur_ps_tdma == 14) {
1656 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1657 true, 15);
1658 coex_dm->tdma_adj_type = 15;
1659 } else if (coex_dm->cur_ps_tdma == 15) {
1660 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1661 true, 16);
1662 coex_dm->tdma_adj_type = 16;
1663 }
1664 } else if (result == 1) {
1665 if (coex_dm->cur_ps_tdma == 8) {
1666 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1667 true, 7);
1668 coex_dm->tdma_adj_type = 7;
1669 } else if (coex_dm->cur_ps_tdma == 7) {
1670 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1671 true, 6);
1672 coex_dm->tdma_adj_type = 6;
1673 } else if (coex_dm->cur_ps_tdma == 6) {
1674 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1675 true, 5);
1676 coex_dm->tdma_adj_type = 5;
1677 } else if (coex_dm->cur_ps_tdma == 16) {
1678 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1679 true, 15);
1680 coex_dm->tdma_adj_type = 15;
1681 } else if (coex_dm->cur_ps_tdma == 15) {
1682 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1683 true, 14);
1684 coex_dm->tdma_adj_type = 14;
1685 } else if (coex_dm->cur_ps_tdma == 14) {
1686 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1687 true, 13);
1688 coex_dm->tdma_adj_type = 13;
1689 }
1690 }
1691 } else {
1692 BTC_PRINT(BTC_MSG_ALGORITHM,
1693 ALGO_TRACE_FW_DETAIL,
1694 "[BTCoex], TxPause = 0\n");
1695 if (coex_dm->cur_ps_tdma == 5) {
1696 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1697 true, 71);
1698 coex_dm->tdma_adj_type = 71;
1699 } else if (coex_dm->cur_ps_tdma == 6) {
1700 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1701 true, 2);
1702 coex_dm->tdma_adj_type = 2;
1703 } else if (coex_dm->cur_ps_tdma == 7) {
1704 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1705 true, 3);
1706 coex_dm->tdma_adj_type = 3;
1707 } else if (coex_dm->cur_ps_tdma == 8) {
1708 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1709 true, 4);
1710 coex_dm->tdma_adj_type = 4;
1711 }
1712 if (coex_dm->cur_ps_tdma == 13) {
1713 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1714 true, 9);
1715 coex_dm->tdma_adj_type = 9;
1716 } else if (coex_dm->cur_ps_tdma == 14) {
1717 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1718 true, 10);
1719 coex_dm->tdma_adj_type = 10;
1720 } else if (coex_dm->cur_ps_tdma == 15) {
1721 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1722 true, 11);
1723 coex_dm->tdma_adj_type = 11;
1724 } else if (coex_dm->cur_ps_tdma == 16) {
1725 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1726 true, 12);
1727 coex_dm->tdma_adj_type = 12;
1728 }
1729
1730 if (result == -1) {
1731 if (coex_dm->cur_ps_tdma == 71) {
1732 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1733 true, 1);
1734 coex_dm->tdma_adj_type = 1;
1735 } else if (coex_dm->cur_ps_tdma == 1) {
1736 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1737 true, 2);
1738 coex_dm->tdma_adj_type = 2;
1739 } else if (coex_dm->cur_ps_tdma == 2) {
1740 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1741 true, 3);
1742 coex_dm->tdma_adj_type = 3;
1743 } else if (coex_dm->cur_ps_tdma == 3) {
1744 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1745 true, 4);
1746 coex_dm->tdma_adj_type = 4;
1747 } else if (coex_dm->cur_ps_tdma == 9) {
1748 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1749 true, 10);
1750 coex_dm->tdma_adj_type = 10;
1751 } else if (coex_dm->cur_ps_tdma == 10) {
1752 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1753 true, 11);
1754 coex_dm->tdma_adj_type = 11;
1755 } else if (coex_dm->cur_ps_tdma == 11) {
1756 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1757 true, 12);
1758 coex_dm->tdma_adj_type = 12;
1759 }
1760 } else if (result == 1) {
1761 if (coex_dm->cur_ps_tdma == 4) {
1762 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1763 true, 3);
1764 coex_dm->tdma_adj_type = 3;
1765 } else if (coex_dm->cur_ps_tdma == 3) {
1766 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1767 true, 2);
1768 coex_dm->tdma_adj_type = 2;
1769 } else if (coex_dm->cur_ps_tdma == 2) {
1770 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1771 true, 1);
1772 coex_dm->tdma_adj_type = 1;
1773 } else if (coex_dm->cur_ps_tdma == 1) {
1774 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1775 true, 71);
1776 coex_dm->tdma_adj_type = 71;
1777 } else if (coex_dm->cur_ps_tdma == 12) {
1778 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1779 true, 11);
1780 coex_dm->tdma_adj_type = 11;
1781 } else if (coex_dm->cur_ps_tdma == 11) {
1782 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1783 true, 10);
1784 coex_dm->tdma_adj_type = 10;
1785 } else if (coex_dm->cur_ps_tdma == 10) {
1786 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1787 true, 9);
1788 coex_dm->tdma_adj_type = 9;
1789 }
1790 }
1791 }
1792 }
1793
1794 static void btc8192e_int2(struct btc_coexist *btcoexist, bool tx_pause,
1795 int result)
1796 {
1797 if (tx_pause) {
1798 BTC_PRINT(BTC_MSG_ALGORITHM,
1799 ALGO_TRACE_FW_DETAIL,
1800 "[BTCoex], TxPause = 1\n");
1801 if (coex_dm->cur_ps_tdma == 1) {
1802 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1803 true, 6);
1804 coex_dm->tdma_adj_type = 6;
1805 } else if (coex_dm->cur_ps_tdma == 2) {
1806 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1807 true, 6);
1808 coex_dm->tdma_adj_type = 6;
1809 } else if (coex_dm->cur_ps_tdma == 3) {
1810 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1811 true, 7);
1812 coex_dm->tdma_adj_type = 7;
1813 } else if (coex_dm->cur_ps_tdma == 4) {
1814 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1815 true, 8);
1816 coex_dm->tdma_adj_type = 8;
1817 }
1818 if (coex_dm->cur_ps_tdma == 9) {
1819 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1820 true, 14);
1821 coex_dm->tdma_adj_type = 14;
1822 } else if (coex_dm->cur_ps_tdma == 10) {
1823 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1824 true, 14);
1825 coex_dm->tdma_adj_type = 14;
1826 } else if (coex_dm->cur_ps_tdma == 11) {
1827 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1828 true, 15);
1829 coex_dm->tdma_adj_type = 15;
1830 } else if (coex_dm->cur_ps_tdma == 12) {
1831 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1832 true, 16);
1833 coex_dm->tdma_adj_type = 16;
1834 }
1835 if (result == -1) {
1836 if (coex_dm->cur_ps_tdma == 5) {
1837 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1838 true, 6);
1839 coex_dm->tdma_adj_type = 6;
1840 } else if (coex_dm->cur_ps_tdma == 6) {
1841 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1842 true, 7);
1843 coex_dm->tdma_adj_type = 7;
1844 } else if (coex_dm->cur_ps_tdma == 7) {
1845 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1846 true, 8);
1847 coex_dm->tdma_adj_type = 8;
1848 } else if (coex_dm->cur_ps_tdma == 13) {
1849 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1850 true, 14);
1851 coex_dm->tdma_adj_type = 14;
1852 } else if (coex_dm->cur_ps_tdma == 14) {
1853 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1854 true, 15);
1855 coex_dm->tdma_adj_type = 15;
1856 } else if (coex_dm->cur_ps_tdma == 15) {
1857 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1858 true, 16);
1859 coex_dm->tdma_adj_type = 16;
1860 }
1861 } else if (result == 1) {
1862 if (coex_dm->cur_ps_tdma == 8) {
1863 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1864 true, 7);
1865 coex_dm->tdma_adj_type = 7;
1866 } else if (coex_dm->cur_ps_tdma == 7) {
1867 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1868 true, 6);
1869 coex_dm->tdma_adj_type = 6;
1870 } else if (coex_dm->cur_ps_tdma == 6) {
1871 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1872 true, 6);
1873 coex_dm->tdma_adj_type = 6;
1874 } else if (coex_dm->cur_ps_tdma == 16) {
1875 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1876 true, 15);
1877 coex_dm->tdma_adj_type = 15;
1878 } else if (coex_dm->cur_ps_tdma == 15) {
1879 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1880 true, 14);
1881 coex_dm->tdma_adj_type = 14;
1882 } else if (coex_dm->cur_ps_tdma == 14) {
1883 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1884 true, 14);
1885 coex_dm->tdma_adj_type = 14;
1886 }
1887 }
1888 } else {
1889 BTC_PRINT(BTC_MSG_ALGORITHM,
1890 ALGO_TRACE_FW_DETAIL,
1891 "[BTCoex], TxPause = 0\n");
1892 if (coex_dm->cur_ps_tdma == 5) {
1893 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1894 true, 2);
1895 coex_dm->tdma_adj_type = 2;
1896 } else if (coex_dm->cur_ps_tdma == 6) {
1897 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1898 true, 2);
1899 coex_dm->tdma_adj_type = 2;
1900 } else if (coex_dm->cur_ps_tdma == 7) {
1901 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1902 true, 3);
1903 coex_dm->tdma_adj_type = 3;
1904 } else if (coex_dm->cur_ps_tdma == 8) {
1905 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1906 true, 4);
1907 coex_dm->tdma_adj_type = 4;
1908 }
1909 if (coex_dm->cur_ps_tdma == 13) {
1910 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1911 true, 10);
1912 coex_dm->tdma_adj_type = 10;
1913 } else if (coex_dm->cur_ps_tdma == 14) {
1914 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1915 true, 10);
1916 coex_dm->tdma_adj_type = 10;
1917 } else if (coex_dm->cur_ps_tdma == 15) {
1918 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1919 true, 11);
1920 coex_dm->tdma_adj_type = 11;
1921 } else if (coex_dm->cur_ps_tdma == 16) {
1922 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1923 true, 12);
1924 coex_dm->tdma_adj_type = 12;
1925 }
1926 if (result == -1) {
1927 if (coex_dm->cur_ps_tdma == 1) {
1928 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1929 true, 2);
1930 coex_dm->tdma_adj_type = 2;
1931 } else if (coex_dm->cur_ps_tdma == 2) {
1932 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1933 true, 3);
1934 coex_dm->tdma_adj_type = 3;
1935 } else if (coex_dm->cur_ps_tdma == 3) {
1936 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1937 true, 4);
1938 coex_dm->tdma_adj_type = 4;
1939 } else if (coex_dm->cur_ps_tdma == 9) {
1940 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1941 true, 10);
1942 coex_dm->tdma_adj_type = 10;
1943 } else if (coex_dm->cur_ps_tdma == 10) {
1944 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1945 true, 11);
1946 coex_dm->tdma_adj_type = 11;
1947 } else if (coex_dm->cur_ps_tdma == 11) {
1948 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1949 true, 12);
1950 coex_dm->tdma_adj_type = 12;
1951 }
1952 } else if (result == 1) {
1953 if (coex_dm->cur_ps_tdma == 4) {
1954 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1955 true, 3);
1956 coex_dm->tdma_adj_type = 3;
1957 } else if (coex_dm->cur_ps_tdma == 3) {
1958 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1959 true, 2);
1960 coex_dm->tdma_adj_type = 2;
1961 } else if (coex_dm->cur_ps_tdma == 2) {
1962 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1963 true, 2);
1964 coex_dm->tdma_adj_type = 2;
1965 } else if (coex_dm->cur_ps_tdma == 12) {
1966 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1967 true, 11);
1968 coex_dm->tdma_adj_type = 11;
1969 } else if (coex_dm->cur_ps_tdma == 11) {
1970 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1971 true, 10);
1972 coex_dm->tdma_adj_type = 10;
1973 } else if (coex_dm->cur_ps_tdma == 10) {
1974 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1975 true, 10);
1976 coex_dm->tdma_adj_type = 10;
1977 }
1978 }
1979 }
1980 }
1981
1982 static void btc8192e_int3(struct btc_coexist *btcoexist, bool tx_pause,
1983 int result)
1984 {
1985 if (tx_pause) {
1986 BTC_PRINT(BTC_MSG_ALGORITHM,
1987 ALGO_TRACE_FW_DETAIL,
1988 "[BTCoex], TxPause = 1\n");
1989 if (coex_dm->cur_ps_tdma == 1) {
1990 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1991 true, 7);
1992 coex_dm->tdma_adj_type = 7;
1993 } else if (coex_dm->cur_ps_tdma == 2) {
1994 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1995 true, 7);
1996 coex_dm->tdma_adj_type = 7;
1997 } else if (coex_dm->cur_ps_tdma == 3) {
1998 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1999 true, 7);
2000 coex_dm->tdma_adj_type = 7;
2001 } else if (coex_dm->cur_ps_tdma == 4) {
2002 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2003 true, 8);
2004 coex_dm->tdma_adj_type = 8;
2005 }
2006 if (coex_dm->cur_ps_tdma == 9) {
2007 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2008 true, 15);
2009 coex_dm->tdma_adj_type = 15;
2010 } else if (coex_dm->cur_ps_tdma == 10) {
2011 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2012 true, 15);
2013 coex_dm->tdma_adj_type = 15;
2014 } else if (coex_dm->cur_ps_tdma == 11) {
2015 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2016 true, 15);
2017 coex_dm->tdma_adj_type = 15;
2018 } else if (coex_dm->cur_ps_tdma == 12) {
2019 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2020 true, 16);
2021 coex_dm->tdma_adj_type = 16;
2022 }
2023 if (result == -1) {
2024 if (coex_dm->cur_ps_tdma == 5) {
2025 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2026 true, 7);
2027 coex_dm->tdma_adj_type = 7;
2028 } else if (coex_dm->cur_ps_tdma == 6) {
2029 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2030 true, 7);
2031 coex_dm->tdma_adj_type = 7;
2032 } else if (coex_dm->cur_ps_tdma == 7) {
2033 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2034 true, 8);
2035 coex_dm->tdma_adj_type = 8;
2036 } else if (coex_dm->cur_ps_tdma == 13) {
2037 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2038 true, 15);
2039 coex_dm->tdma_adj_type = 15;
2040 } else if (coex_dm->cur_ps_tdma == 14) {
2041 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2042 true, 15);
2043 coex_dm->tdma_adj_type = 15;
2044 } else if (coex_dm->cur_ps_tdma == 15) {
2045 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2046 true, 16);
2047 coex_dm->tdma_adj_type = 16;
2048 }
2049 } else if (result == 1) {
2050 if (coex_dm->cur_ps_tdma == 8) {
2051 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2052 true, 7);
2053 coex_dm->tdma_adj_type = 7;
2054 } else if (coex_dm->cur_ps_tdma == 7) {
2055 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2056 true, 7);
2057 coex_dm->tdma_adj_type = 7;
2058 } else if (coex_dm->cur_ps_tdma == 6) {
2059 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2060 true, 7);
2061 coex_dm->tdma_adj_type = 7;
2062 } else if (coex_dm->cur_ps_tdma == 16) {
2063 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2064 true, 15);
2065 coex_dm->tdma_adj_type = 15;
2066 } else if (coex_dm->cur_ps_tdma == 15) {
2067 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2068 true, 15);
2069 coex_dm->tdma_adj_type = 15;
2070 } else if (coex_dm->cur_ps_tdma == 14) {
2071 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2072 true, 15);
2073 coex_dm->tdma_adj_type = 15;
2074 }
2075 }
2076 } else {
2077 BTC_PRINT(BTC_MSG_ALGORITHM,
2078 ALGO_TRACE_FW_DETAIL,
2079 "[BTCoex], TxPause = 0\n");
2080 if (coex_dm->cur_ps_tdma == 5) {
2081 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2082 true, 3);
2083 coex_dm->tdma_adj_type = 3;
2084 } else if (coex_dm->cur_ps_tdma == 6) {
2085 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2086 true, 3);
2087 coex_dm->tdma_adj_type = 3;
2088 } else if (coex_dm->cur_ps_tdma == 7) {
2089 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2090 true, 3);
2091 coex_dm->tdma_adj_type = 3;
2092 } else if (coex_dm->cur_ps_tdma == 8) {
2093 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2094 true, 4);
2095 coex_dm->tdma_adj_type = 4;
2096 }
2097 if (coex_dm->cur_ps_tdma == 13) {
2098 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2099 true, 11);
2100 coex_dm->tdma_adj_type = 11;
2101 } else if (coex_dm->cur_ps_tdma == 14) {
2102 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2103 true, 11);
2104 coex_dm->tdma_adj_type = 11;
2105 } else if (coex_dm->cur_ps_tdma == 15) {
2106 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2107 true, 11);
2108 coex_dm->tdma_adj_type = 11;
2109 } else if (coex_dm->cur_ps_tdma == 16) {
2110 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2111 true, 12);
2112 coex_dm->tdma_adj_type = 12;
2113 }
2114 if (result == -1) {
2115 if (coex_dm->cur_ps_tdma == 1) {
2116 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2117 true, 3);
2118 coex_dm->tdma_adj_type = 3;
2119 } else if (coex_dm->cur_ps_tdma == 2) {
2120 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2121 true, 3);
2122 coex_dm->tdma_adj_type = 3;
2123 } else if (coex_dm->cur_ps_tdma == 3) {
2124 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2125 true, 4);
2126 coex_dm->tdma_adj_type = 4;
2127 } else if (coex_dm->cur_ps_tdma == 9) {
2128 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2129 true, 11);
2130 coex_dm->tdma_adj_type = 11;
2131 } else if (coex_dm->cur_ps_tdma == 10) {
2132 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2133 true, 11);
2134 coex_dm->tdma_adj_type = 11;
2135 } else if (coex_dm->cur_ps_tdma == 11) {
2136 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2137 true, 12);
2138 coex_dm->tdma_adj_type = 12;
2139 }
2140 } else if (result == 1) {
2141 if (coex_dm->cur_ps_tdma == 4) {
2142 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2143 true, 3);
2144 coex_dm->tdma_adj_type = 3;
2145 } else if (coex_dm->cur_ps_tdma == 3) {
2146 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2147 true, 3);
2148 coex_dm->tdma_adj_type = 3;
2149 } else if (coex_dm->cur_ps_tdma == 2) {
2150 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2151 true, 3);
2152 coex_dm->tdma_adj_type = 3;
2153 } else if (coex_dm->cur_ps_tdma == 12) {
2154 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2155 true, 11);
2156 coex_dm->tdma_adj_type = 11;
2157 } else if (coex_dm->cur_ps_tdma == 11) {
2158 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2159 true, 11);
2160 coex_dm->tdma_adj_type = 11;
2161 } else if (coex_dm->cur_ps_tdma == 10) {
2162 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2163 true, 11);
2164 coex_dm->tdma_adj_type = 11;
2165 }
2166 }
2167 }
2168 }
2169
2170 static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
2171 bool sco_hid, bool tx_pause,
2172 u8 max_interval)
2173 {
2174 static int up, dn, m, n, wait_cnt;
2175 /* 0: no change, +1: increase WiFi duration,
2176 * -1: decrease WiFi duration
2177 */
2178 int result;
2179 u8 retry_cnt = 0;
2180
2181 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
2182 "[BTCoex], TdmaDurationAdjust()\n");
2183
2184 if (!coex_dm->auto_tdma_adjust) {
2185 coex_dm->auto_tdma_adjust = true;
2186 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2187 "[BTCoex], first run TdmaDurationAdjust()!!\n");
2188 if (sco_hid) {
2189 if (tx_pause) {
2190 if (max_interval == 1) {
2191 halbtc8192e2ant_ps_tdma(btcoexist,
2192 NORMAL_EXEC,
2193 true, 13);
2194 coex_dm->tdma_adj_type = 13;
2195 } else if (max_interval == 2) {
2196 halbtc8192e2ant_ps_tdma(btcoexist,
2197 NORMAL_EXEC,
2198 true, 14);
2199 coex_dm->tdma_adj_type = 14;
2200 } else if (max_interval == 3) {
2201 halbtc8192e2ant_ps_tdma(btcoexist,
2202 NORMAL_EXEC,
2203 true, 15);
2204 coex_dm->tdma_adj_type = 15;
2205 } else {
2206 halbtc8192e2ant_ps_tdma(btcoexist,
2207 NORMAL_EXEC,
2208 true, 15);
2209 coex_dm->tdma_adj_type = 15;
2210 }
2211 } else {
2212 if (max_interval == 1) {
2213 halbtc8192e2ant_ps_tdma(btcoexist,
2214 NORMAL_EXEC,
2215 true, 9);
2216 coex_dm->tdma_adj_type = 9;
2217 } else if (max_interval == 2) {
2218 halbtc8192e2ant_ps_tdma(btcoexist,
2219 NORMAL_EXEC,
2220 true, 10);
2221 coex_dm->tdma_adj_type = 10;
2222 } else if (max_interval == 3) {
2223 halbtc8192e2ant_ps_tdma(btcoexist,
2224 NORMAL_EXEC,
2225 true, 11);
2226 coex_dm->tdma_adj_type = 11;
2227 } else {
2228 halbtc8192e2ant_ps_tdma(btcoexist,
2229 NORMAL_EXEC,
2230 true, 11);
2231 coex_dm->tdma_adj_type = 11;
2232 }
2233 }
2234 } else {
2235 if (tx_pause) {
2236 if (max_interval == 1) {
2237 halbtc8192e2ant_ps_tdma(btcoexist,
2238 NORMAL_EXEC,
2239 true, 5);
2240 coex_dm->tdma_adj_type = 5;
2241 } else if (max_interval == 2) {
2242 halbtc8192e2ant_ps_tdma(btcoexist,
2243 NORMAL_EXEC,
2244 true, 6);
2245 coex_dm->tdma_adj_type = 6;
2246 } else if (max_interval == 3) {
2247 halbtc8192e2ant_ps_tdma(btcoexist,
2248 NORMAL_EXEC,
2249 true, 7);
2250 coex_dm->tdma_adj_type = 7;
2251 } else {
2252 halbtc8192e2ant_ps_tdma(btcoexist,
2253 NORMAL_EXEC,
2254 true, 7);
2255 coex_dm->tdma_adj_type = 7;
2256 }
2257 } else {
2258 if (max_interval == 1) {
2259 halbtc8192e2ant_ps_tdma(btcoexist,
2260 NORMAL_EXEC,
2261 true, 1);
2262 coex_dm->tdma_adj_type = 1;
2263 } else if (max_interval == 2) {
2264 halbtc8192e2ant_ps_tdma(btcoexist,
2265 NORMAL_EXEC,
2266 true, 2);
2267 coex_dm->tdma_adj_type = 2;
2268 } else if (max_interval == 3) {
2269 halbtc8192e2ant_ps_tdma(btcoexist,
2270 NORMAL_EXEC,
2271 true, 3);
2272 coex_dm->tdma_adj_type = 3;
2273 } else {
2274 halbtc8192e2ant_ps_tdma(btcoexist,
2275 NORMAL_EXEC,
2276 true, 3);
2277 coex_dm->tdma_adj_type = 3;
2278 }
2279 }
2280 }
2281
2282 up = 0;
2283 dn = 0;
2284 m = 1;
2285 n = 3;
2286 result = 0;
2287 wait_cnt = 0;
2288 } else {
2289 /* accquire the BT TRx retry count from BT_Info byte2 */
2290 retry_cnt = coex_sta->bt_retry_cnt;
2291 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2292 "[BTCoex], retry_cnt = %d\n", retry_cnt);
2293 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2294 "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_cnt=%d\n",
2295 up, dn, m, n, wait_cnt);
2296 result = 0;
2297 wait_cnt++;
2298 /* no retry in the last 2-second duration */
2299 if (retry_cnt == 0) {
2300 up++;
2301 dn--;
2302
2303 if (dn <= 0)
2304 dn = 0;
2305
2306 if (up >= n) {
2307 wait_cnt = 0;
2308 n = 3;
2309 up = 0;
2310 dn = 0;
2311 result = 1;
2312 BTC_PRINT(BTC_MSG_ALGORITHM,
2313 ALGO_TRACE_FW_DETAIL,
2314 "[BTCoex]Increase wifi duration!!\n");
2315 }
2316 } else if (retry_cnt <= 3) {
2317 up--;
2318 dn++;
2319
2320 if (up <= 0)
2321 up = 0;
2322
2323 if (dn == 2) {
2324 if (wait_cnt <= 2)
2325 m++;
2326 else
2327 m = 1;
2328
2329 if (m >= 20)
2330 m = 20;
2331
2332 n = 3 * m;
2333 up = 0;
2334 dn = 0;
2335 wait_cnt = 0;
2336 result = -1;
2337 BTC_PRINT(BTC_MSG_ALGORITHM,
2338 ALGO_TRACE_FW_DETAIL,
2339 "Reduce wifi duration for retry<3\n");
2340 }
2341 } else {
2342 if (wait_cnt == 1)
2343 m++;
2344 else
2345 m = 1;
2346
2347 if (m >= 20)
2348 m = 20;
2349
2350 n = 3*m;
2351 up = 0;
2352 dn = 0;
2353 wait_cnt = 0;
2354 result = -1;
2355 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2356 "Decrease wifi duration for retryCounter>3!!\n");
2357 }
2358
2359 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2360 "[BTCoex], max Interval = %d\n", max_interval);
2361 if (max_interval == 1)
2362 btc8192e_int1(btcoexist, tx_pause, result);
2363 else if (max_interval == 2)
2364 btc8192e_int2(btcoexist, tx_pause, result);
2365 else if (max_interval == 3)
2366 btc8192e_int3(btcoexist, tx_pause, result);
2367 }
2368
2369 /* if current PsTdma not match with
2370 * the recorded one (when scan, dhcp...),
2371 * then we have to adjust it back to the previous record one.
2372 */
2373 if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
2374 bool scan = false, link = false, roam = false;
2375
2376 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2377 "[BTCoex], PsTdma type dismatch!!!, ");
2378 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2379 "curPsTdma=%d, recordPsTdma=%d\n",
2380 coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
2381
2382 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2383 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2384 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2385
2386 if (!scan && !link && !roam)
2387 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2388 true,
2389 coex_dm->tdma_adj_type);
2390 else
2391 BTC_PRINT(BTC_MSG_ALGORITHM,
2392 ALGO_TRACE_FW_DETAIL,
2393 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2394 }
2395 }
2396
2397 /* SCO only or SCO+PAN(HS) */
2398 static void halbtc8192e2ant_action_sco(struct btc_coexist *btcoexist)
2399 {
2400 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_STAY_LOW;
2401 u32 wifi_bw;
2402
2403 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2404
2405 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2406 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2407
2408 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2409
2410 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 4);
2411
2412 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2413
2414 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2415 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2416 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2417 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2418 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2419 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2420 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2421 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2422 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2423 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2424 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2425 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2426 }
2427
2428 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2429
2430 /* sw mechanism */
2431 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2432 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2433 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2434 btc8192e2ant_sw_mec1(btcoexist, true, true,
2435 false, false);
2436 btc8192e2ant_sw_mec2(btcoexist, true, false,
2437 false, 0x6);
2438 } else {
2439 btc8192e2ant_sw_mec1(btcoexist, true, true,
2440 false, false);
2441 btc8192e2ant_sw_mec2(btcoexist, false, false,
2442 false, 0x6);
2443 }
2444 } else {
2445 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2446 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2447 btc8192e2ant_sw_mec1(btcoexist, false, true,
2448 false, false);
2449 btc8192e2ant_sw_mec2(btcoexist, true, false,
2450 false, 0x6);
2451 } else {
2452 btc8192e2ant_sw_mec1(btcoexist, false, true,
2453 false, false);
2454 btc8192e2ant_sw_mec2(btcoexist, false, false,
2455 false, 0x6);
2456 }
2457 }
2458 }
2459
2460 static void halbtc8192e2ant_action_sco_pan(struct btc_coexist *btcoexist)
2461 {
2462 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_STAY_LOW;
2463 u32 wifi_bw;
2464
2465 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2466
2467 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2468 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2469
2470 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2471
2472 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 4);
2473
2474 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2475
2476 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2477 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2478 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2479 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2480 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2481 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2482 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2483 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
2484 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2485 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2486 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2487 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
2488 }
2489
2490 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2491
2492 /* sw mechanism */
2493 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2494 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2495 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2496 btc8192e2ant_sw_mec1(btcoexist, true, true,
2497 false, false);
2498 btc8192e2ant_sw_mec2(btcoexist, true, false,
2499 false, 0x6);
2500 } else {
2501 btc8192e2ant_sw_mec1(btcoexist, true, true,
2502 false, false);
2503 btc8192e2ant_sw_mec2(btcoexist, false, false,
2504 false, 0x6);
2505 }
2506 } else {
2507 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2508 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2509 btc8192e2ant_sw_mec1(btcoexist, false, true,
2510 false, false);
2511 btc8192e2ant_sw_mec2(btcoexist, true, false,
2512 false, 0x6);
2513 } else {
2514 btc8192e2ant_sw_mec1(btcoexist, false, true,
2515 false, false);
2516 btc8192e2ant_sw_mec2(btcoexist, false, false,
2517 false, 0x6);
2518 }
2519 }
2520 }
2521
2522 static void halbtc8192e2ant_action_hid(struct btc_coexist *btcoexist)
2523 {
2524 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2525 u32 wifi_bw;
2526
2527 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2528 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2529
2530 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2531 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2532
2533 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2534
2535 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2536
2537 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 3);
2538
2539 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2540 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2541 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2542 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2543 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2544 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2545 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2546 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2547 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2548 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2549 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2550 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2551 }
2552
2553 /* sw mechanism */
2554 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2555 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2556 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2557 btc8192e2ant_sw_mec1(btcoexist, true, true,
2558 false, false);
2559 btc8192e2ant_sw_mec2(btcoexist, true, false,
2560 false, 0x18);
2561 } else {
2562 btc8192e2ant_sw_mec1(btcoexist, true, true,
2563 false, false);
2564 btc8192e2ant_sw_mec2(btcoexist, false, false,
2565 false, 0x18);
2566 }
2567 } else {
2568 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2569 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2570 btc8192e2ant_sw_mec1(btcoexist, false, true,
2571 false, false);
2572 btc8192e2ant_sw_mec2(btcoexist, true, false,
2573 false, 0x18);
2574 } else {
2575 btc8192e2ant_sw_mec1(btcoexist, false, true,
2576 false, false);
2577 btc8192e2ant_sw_mec2(btcoexist, false, false,
2578 false, 0x18);
2579 }
2580 }
2581 }
2582
2583 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2584 static void halbtc8192e2ant_action_a2dp(struct btc_coexist *btcoexist)
2585 {
2586 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2587 u32 wifi_bw;
2588 bool long_dist = false;
2589
2590 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2591 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2592
2593 if ((btrssi_state == BTC_RSSI_STATE_LOW ||
2594 btrssi_state == BTC_RSSI_STATE_STAY_LOW) &&
2595 (wifirssi_state == BTC_RSSI_STATE_LOW ||
2596 wifirssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2597 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2598 "[BTCoex], A2dp, wifi/bt rssi both LOW!!\n");
2599 long_dist = true;
2600 }
2601 if (long_dist) {
2602 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 2);
2603 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true,
2604 0x4);
2605 } else {
2606 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2607 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2608 0x8);
2609 }
2610
2611 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2612
2613 if (long_dist)
2614 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 0);
2615 else
2616 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 2);
2617
2618 if (long_dist) {
2619 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 17);
2620 coex_dm->auto_tdma_adjust = false;
2621 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2622 } else {
2623 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2624 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2625 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2626 true, 1);
2627 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2628 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2629 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2630 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2631 false, 1);
2632 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2633 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2634 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2635 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2636 false, 1);
2637 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2638 }
2639 }
2640
2641 /* sw mechanism */
2642 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2643 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2644 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2645 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2646 btc8192e2ant_sw_mec1(btcoexist, true, false,
2647 false, false);
2648 btc8192e2ant_sw_mec2(btcoexist, true, false,
2649 false, 0x18);
2650 } else {
2651 btc8192e2ant_sw_mec1(btcoexist, true, false,
2652 false, false);
2653 btc8192e2ant_sw_mec2(btcoexist, false, false,
2654 false, 0x18);
2655 }
2656 } else {
2657 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2658 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2659 btc8192e2ant_sw_mec1(btcoexist, false, false,
2660 false, false);
2661 btc8192e2ant_sw_mec2(btcoexist, true, false,
2662 false, 0x18);
2663 } else {
2664 btc8192e2ant_sw_mec1(btcoexist, false, false,
2665 false, false);
2666 btc8192e2ant_sw_mec2(btcoexist, false, false,
2667 false, 0x18);
2668 }
2669 }
2670 }
2671
2672 static void halbtc8192e2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2673 {
2674 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2675 u32 wifi_bw;
2676
2677 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2678 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2679
2680 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2681 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2682
2683 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2684 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 2);
2685
2686 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2687 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2688 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2689 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2690 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2691 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2692 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2693 false, 2);
2694 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2695 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2696 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2697 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2698 false, 2);
2699 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2700 }
2701
2702 /* sw mechanism */
2703 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2704 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2705 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2706 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2707 btc8192e2ant_sw_mec1(btcoexist, true, false,
2708 false, false);
2709 btc8192e2ant_sw_mec2(btcoexist, true, false,
2710 true, 0x6);
2711 } else {
2712 btc8192e2ant_sw_mec1(btcoexist, true, false,
2713 false, false);
2714 btc8192e2ant_sw_mec2(btcoexist, false, false,
2715 true, 0x6);
2716 }
2717 } else {
2718 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2719 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2720 btc8192e2ant_sw_mec1(btcoexist, false, false,
2721 false, false);
2722 btc8192e2ant_sw_mec2(btcoexist, true, false,
2723 true, 0x6);
2724 } else {
2725 btc8192e2ant_sw_mec1(btcoexist, false, false,
2726 false, false);
2727 btc8192e2ant_sw_mec2(btcoexist, false, false,
2728 true, 0x6);
2729 }
2730 }
2731 }
2732
2733 static void halbtc8192e2ant_action_pan_edr(struct btc_coexist *btcoexist)
2734 {
2735 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2736 u32 wifi_bw;
2737
2738 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2739 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2740
2741 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2742 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2743
2744 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2745
2746 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 2);
2747
2748 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2749 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2750 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2751 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2752 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2753 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2754 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2755 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2756 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2757 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2758 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2759 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2760 }
2761
2762 /* sw mechanism */
2763 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2764 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2765 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2766 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2767 btc8192e2ant_sw_mec1(btcoexist, true, false,
2768 false, false);
2769 btc8192e2ant_sw_mec2(btcoexist, true, false,
2770 false, 0x18);
2771 } else {
2772 btc8192e2ant_sw_mec1(btcoexist, true, false,
2773 false, false);
2774 btc8192e2ant_sw_mec2(btcoexist, false, false,
2775 false, 0x18);
2776 }
2777 } else {
2778 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2779 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2780 btc8192e2ant_sw_mec1(btcoexist, false, false,
2781 false, false);
2782 btc8192e2ant_sw_mec2(btcoexist, true, false,
2783 false, 0x18);
2784 } else {
2785 btc8192e2ant_sw_mec1(btcoexist, false, false,
2786 false, false);
2787 btc8192e2ant_sw_mec2(btcoexist, false, false,
2788 false, 0x18);
2789 }
2790 }
2791 }
2792
2793 /* PAN(HS) only */
2794 static void halbtc8192e2ant_action_pan_hs(struct btc_coexist *btcoexist)
2795 {
2796 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2797 u32 wifi_bw;
2798
2799 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2800 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2801
2802 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2803 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2804
2805 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2806
2807 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 2);
2808
2809 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2810 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2811 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2812 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2813 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2814 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2815 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2816 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2817 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2818 }
2819 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2820
2821 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2822 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2823 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2824 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2825 btc8192e2ant_sw_mec1(btcoexist, true, false,
2826 false, false);
2827 btc8192e2ant_sw_mec2(btcoexist, true, false,
2828 false, 0x18);
2829 } else {
2830 btc8192e2ant_sw_mec1(btcoexist, true, false,
2831 false, false);
2832 btc8192e2ant_sw_mec2(btcoexist, false, false,
2833 false, 0x18);
2834 }
2835 } else {
2836 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2837 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2838 btc8192e2ant_sw_mec1(btcoexist, false, false,
2839 false, false);
2840 btc8192e2ant_sw_mec2(btcoexist, true, false,
2841 false, 0x18);
2842 } else {
2843 btc8192e2ant_sw_mec1(btcoexist, false, false,
2844 false, false);
2845 btc8192e2ant_sw_mec2(btcoexist, false, false,
2846 false, 0x18);
2847 }
2848 }
2849 }
2850
2851 /* PAN(EDR)+A2DP */
2852 static void halbtc8192e2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
2853 {
2854 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2855 u32 wifi_bw;
2856
2857 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2858 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2859
2860 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2861 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2862
2863 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2864
2865 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 2);
2866
2867 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2868
2869 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2870 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2871 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2872 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false, true, 3);
2873 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2874 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2875 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2876 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2877 false, 3);
2878 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2879 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2880 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2881 halbtc8192e2ant_tdma_duration_adjust(btcoexist, false,
2882 false, 3);
2883 }
2884
2885 /* sw mechanism */
2886 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2887 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2888 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2889 btc8192e2ant_sw_mec1(btcoexist, true, false,
2890 false, false);
2891 btc8192e2ant_sw_mec2(btcoexist, true, false,
2892 false, 0x18);
2893 } else {
2894 btc8192e2ant_sw_mec1(btcoexist, true, false,
2895 false, false);
2896 btc8192e2ant_sw_mec2(btcoexist, false, false,
2897 false, 0x18);
2898 }
2899 } else {
2900 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2901 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2902 btc8192e2ant_sw_mec1(btcoexist, false, false,
2903 false, false);
2904 btc8192e2ant_sw_mec2(btcoexist, true, false,
2905 false, 0x18);
2906 } else {
2907 btc8192e2ant_sw_mec1(btcoexist, false, false,
2908 false, false);
2909 btc8192e2ant_sw_mec2(btcoexist, false, false,
2910 false, 0x18);
2911 }
2912 }
2913 }
2914
2915 static void halbtc8192e2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
2916 {
2917 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2918 u32 wifi_bw;
2919
2920 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2921 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2922
2923 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2924
2925 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2926 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2927
2928 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2929
2930 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 3);
2931
2932 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2933 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2934 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2935 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2936 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
2937 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
2938 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
2939 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2940 true, 10);
2941 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
2942 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2943 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
2944 halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2945 true, 10);
2946 }
2947
2948 /* sw mechanism */
2949 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2950 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2951 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2952 btc8192e2ant_sw_mec1(btcoexist, true, true,
2953 false, false);
2954 btc8192e2ant_sw_mec2(btcoexist, true, false,
2955 false, 0x18);
2956 } else {
2957 btc8192e2ant_sw_mec1(btcoexist, true, true,
2958 false, false);
2959 btc8192e2ant_sw_mec2(btcoexist, false, false,
2960 false, 0x18);
2961 }
2962 } else {
2963 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
2964 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2965 btc8192e2ant_sw_mec1(btcoexist, false, true,
2966 false, false);
2967 btc8192e2ant_sw_mec2(btcoexist, true, false,
2968 false, 0x18);
2969 } else {
2970 btc8192e2ant_sw_mec1(btcoexist, false, true,
2971 false, false);
2972 btc8192e2ant_sw_mec2(btcoexist, false, false,
2973 false, 0x18);
2974 }
2975 }
2976 }
2977
2978 /* HID+A2DP+PAN(EDR) */
2979 static void btc8192e2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
2980 {
2981 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
2982 u32 wifi_bw;
2983
2984 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
2985 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
2986
2987 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
2988 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2989
2990 halbtc8192e2ant_fw_dac_swinglvl(btcoexist, NORMAL_EXEC, 6);
2991
2992 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2993
2994 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 3);
2995
2996 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
2997 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
2998 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
2999 halbtc8192e2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3000 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
3001 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
3002 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
3003 halbtc8192e2ant_tdma_duration_adjust(btcoexist, true, false, 3);
3004 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
3005 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3006 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
3007 halbtc8192e2ant_tdma_duration_adjust(btcoexist, true, false, 3);
3008 }
3009
3010 /* sw mechanism */
3011 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3012 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
3013 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3014 btc8192e2ant_sw_mec1(btcoexist, true, true,
3015 false, false);
3016 btc8192e2ant_sw_mec2(btcoexist, true, false,
3017 false, 0x18);
3018 } else {
3019 btc8192e2ant_sw_mec1(btcoexist, true, true,
3020 false, false);
3021 btc8192e2ant_sw_mec2(btcoexist, false, false,
3022 false, 0x18);
3023 }
3024 } else {
3025 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
3026 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3027 btc8192e2ant_sw_mec1(btcoexist, false, true,
3028 false, false);
3029 btc8192e2ant_sw_mec2(btcoexist, true, false,
3030 false, 0x18);
3031 } else {
3032 btc8192e2ant_sw_mec1(btcoexist, false, true,
3033 false, false);
3034 btc8192e2ant_sw_mec2(btcoexist, false, false,
3035 false, 0x18);
3036 }
3037 }
3038 }
3039
3040 static void halbtc8192e2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3041 {
3042 u8 wifirssi_state, btrssi_state = BTC_RSSI_STATE_HIGH;
3043 u32 wifi_bw;
3044
3045 wifirssi_state = halbtc8192e2ant_wifirssi_state(btcoexist, 0, 2, 15, 0);
3046 btrssi_state = halbtc8192e2ant_btrssi_state(3, 34, 42);
3047
3048 halbtc8192e2ant_switch_sstype(btcoexist, NORMAL_EXEC, 1);
3049 halbtc8192e2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3050
3051 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3052
3053 btc8192e2ant_coex_tbl_w_type(btcoexist, NORMAL_EXEC, 3);
3054
3055 if ((btrssi_state == BTC_RSSI_STATE_LOW) ||
3056 (btrssi_state == BTC_RSSI_STATE_STAY_LOW)) {
3057 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 0);
3058 halbtc8192e2ant_tdma_duration_adjust(btcoexist, true, true, 2);
3059 } else if ((btrssi_state == BTC_RSSI_STATE_MEDIUM) ||
3060 (btrssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
3061 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 2);
3062 halbtc8192e2ant_tdma_duration_adjust(btcoexist, true, false, 2);
3063 } else if ((btrssi_state == BTC_RSSI_STATE_HIGH) ||
3064 (btrssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3065 halbtc8192e2ant_dec_btpwr(btcoexist, NORMAL_EXEC, 4);
3066 halbtc8192e2ant_tdma_duration_adjust(btcoexist, true, false, 2);
3067 }
3068
3069 /* sw mechanism */
3070 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3071 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
3072 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3073 btc8192e2ant_sw_mec1(btcoexist, true, true,
3074 false, false);
3075 btc8192e2ant_sw_mec2(btcoexist, true, false,
3076 false, 0x18);
3077 } else {
3078 btc8192e2ant_sw_mec1(btcoexist, true, true,
3079 false, false);
3080 btc8192e2ant_sw_mec2(btcoexist, false, false,
3081 false, 0x18);
3082 }
3083 } else {
3084 if ((wifirssi_state == BTC_RSSI_STATE_HIGH) ||
3085 (wifirssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3086 btc8192e2ant_sw_mec1(btcoexist, false, true,
3087 false, false);
3088 btc8192e2ant_sw_mec2(btcoexist, true, false,
3089 false, 0x18);
3090 } else {
3091 btc8192e2ant_sw_mec1(btcoexist, false, true,
3092 false, false);
3093 btc8192e2ant_sw_mec2(btcoexist, false, false,
3094 false, 0x18);
3095 }
3096 }
3097 }
3098
3099 static void halbtc8192e2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3100 {
3101 u8 algorithm = 0;
3102
3103 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3104 "[BTCoex], RunCoexistMechanism()===>\n");
3105
3106 if (btcoexist->manual_control) {
3107 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3108 "[BTCoex], return for Manual CTRL <===\n");
3109 return;
3110 }
3111
3112 if (coex_sta->under_ips) {
3113 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3114 "[BTCoex], wifi is under IPS !!!\n");
3115 return;
3116 }
3117
3118 algorithm = halbtc8192e2ant_action_algorithm(btcoexist);
3119 if (coex_sta->c2h_bt_inquiry_page &&
3120 (BT_8192E_2ANT_COEX_ALGO_PANHS != algorithm)) {
3121 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3122 "[BTCoex], BT is under inquiry/page scan !!\n");
3123 halbtc8192e2ant_action_bt_inquiry(btcoexist);
3124 return;
3125 }
3126
3127 coex_dm->cur_algorithm = algorithm;
3128 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3129 "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
3130
3131 if (halbtc8192e2ant_is_common_action(btcoexist)) {
3132 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3133 "[BTCoex], Action 2-Ant common.\n");
3134 coex_dm->auto_tdma_adjust = false;
3135 } else {
3136 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3137 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3138 "[BTCoex] preAlgorithm=%d, curAlgorithm=%d\n",
3139 coex_dm->pre_algorithm,
3140 coex_dm->cur_algorithm);
3141 coex_dm->auto_tdma_adjust = false;
3142 }
3143 switch (coex_dm->cur_algorithm) {
3144 case BT_8192E_2ANT_COEX_ALGO_SCO:
3145 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3146 "Action 2-Ant, algorithm = SCO.\n");
3147 halbtc8192e2ant_action_sco(btcoexist);
3148 break;
3149 case BT_8192E_2ANT_COEX_ALGO_SCO_PAN:
3150 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3151 "Action 2-Ant, algorithm = SCO+PAN(EDR).\n");
3152 halbtc8192e2ant_action_sco_pan(btcoexist);
3153 break;
3154 case BT_8192E_2ANT_COEX_ALGO_HID:
3155 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3156 "Action 2-Ant, algorithm = HID.\n");
3157 halbtc8192e2ant_action_hid(btcoexist);
3158 break;
3159 case BT_8192E_2ANT_COEX_ALGO_A2DP:
3160 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3161 "Action 2-Ant, algorithm = A2DP.\n");
3162 halbtc8192e2ant_action_a2dp(btcoexist);
3163 break;
3164 case BT_8192E_2ANT_COEX_ALGO_A2DP_PANHS:
3165 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3166 "Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
3167 halbtc8192e2ant_action_a2dp_pan_hs(btcoexist);
3168 break;
3169 case BT_8192E_2ANT_COEX_ALGO_PANEDR:
3170 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3171 "Action 2-Ant, algorithm = PAN(EDR).\n");
3172 halbtc8192e2ant_action_pan_edr(btcoexist);
3173 break;
3174 case BT_8192E_2ANT_COEX_ALGO_PANHS:
3175 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3176 "Action 2-Ant, algorithm = HS mode.\n");
3177 halbtc8192e2ant_action_pan_hs(btcoexist);
3178 break;
3179 case BT_8192E_2ANT_COEX_ALGO_PANEDR_A2DP:
3180 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3181 "Action 2-Ant, algorithm = PAN+A2DP.\n");
3182 halbtc8192e2ant_action_pan_edr_a2dp(btcoexist);
3183 break;
3184 case BT_8192E_2ANT_COEX_ALGO_PANEDR_HID:
3185 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3186 "Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
3187 halbtc8192e2ant_action_pan_edr_hid(btcoexist);
3188 break;
3189 case BT_8192E_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3190 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3191 "Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
3192 btc8192e2ant_action_hid_a2dp_pan_edr(btcoexist);
3193 break;
3194 case BT_8192E_2ANT_COEX_ALGO_HID_A2DP:
3195 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3196 "Action 2-Ant, algorithm = HID+A2DP.\n");
3197 halbtc8192e2ant_action_hid_a2dp(btcoexist);
3198 break;
3199 default:
3200 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3201 "Action 2-Ant, algorithm = unknown!!\n");
3202 /* halbtc8192e2ant_coex_alloff(btcoexist); */
3203 break;
3204 }
3205 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3206 }
3207 }
3208
3209 static void halbtc8192e2ant_init_hwconfig(struct btc_coexist *btcoexist,
3210 bool backup)
3211 {
3212 u16 u16tmp = 0;
3213 u8 u8tmp = 0;
3214
3215 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3216 "[BTCoex], 2Ant Init HW Config!!\n");
3217
3218 if (backup) {
3219 /* backup rf 0x1e value */
3220 coex_dm->bt_rf0x1e_backup =
3221 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A,
3222 0x1e, 0xfffff);
3223
3224 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
3225 0x430);
3226 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
3227 0x434);
3228 coex_dm->backup_retrylimit = btcoexist->btc_read_2byte(
3229 btcoexist,
3230 0x42a);
3231 coex_dm->backup_ampdu_maxtime = btcoexist->btc_read_1byte(
3232 btcoexist,
3233 0x456);
3234 }
3235
3236 /* antenna sw ctrl to bt */
3237 btcoexist->btc_write_1byte(btcoexist, 0x4f, 0x6);
3238 btcoexist->btc_write_1byte(btcoexist, 0x944, 0x24);
3239 btcoexist->btc_write_4byte(btcoexist, 0x930, 0x700700);
3240 btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x20);
3241 if (btcoexist->chip_interface == BTC_INTF_USB)
3242 btcoexist->btc_write_4byte(btcoexist, 0x64, 0x30430004);
3243 else
3244 btcoexist->btc_write_4byte(btcoexist, 0x64, 0x30030004);
3245
3246 btc8192e2ant_coex_tbl_w_type(btcoexist, FORCE_EXEC, 0);
3247
3248 /* antenna switch control parameter */
3249 btcoexist->btc_write_4byte(btcoexist, 0x858, 0x55555555);
3250
3251 /* coex parameters */
3252 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3253 /* 0x790[5:0] = 0x5 */
3254 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3255 u8tmp &= 0xc0;
3256 u8tmp |= 0x5;
3257 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3258
3259 /* enable counter statistics */
3260 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3261
3262 /* enable PTA */
3263 btcoexist->btc_write_1byte(btcoexist, 0x40, 0x20);
3264 /* enable mailbox interface */
3265 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x40);
3266 u16tmp |= BIT9;
3267 btcoexist->btc_write_2byte(btcoexist, 0x40, u16tmp);
3268
3269 /* enable PTA I2C mailbox */
3270 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x101);
3271 u8tmp |= BIT4;
3272 btcoexist->btc_write_1byte(btcoexist, 0x101, u8tmp);
3273
3274 /* enable bt clock when wifi is disabled. */
3275 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x93);
3276 u8tmp |= BIT0;
3277 btcoexist->btc_write_1byte(btcoexist, 0x93, u8tmp);
3278 /* enable bt clock when suspend. */
3279 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x7);
3280 u8tmp |= BIT0;
3281 btcoexist->btc_write_1byte(btcoexist, 0x7, u8tmp);
3282 }
3283
3284 /*************************************************************
3285 * work around function start with wa_halbtc8192e2ant_
3286 *************************************************************/
3287
3288 /************************************************************
3289 * extern function start with EXhalbtc8192e2ant_
3290 ************************************************************/
3291
3292 void ex_halbtc8192e2ant_init_hwconfig(struct btc_coexist *btcoexist)
3293 {
3294 halbtc8192e2ant_init_hwconfig(btcoexist, true);
3295 }
3296
3297 void ex_halbtc8192e2ant_init_coex_dm(struct btc_coexist *btcoexist)
3298 {
3299 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3300 "[BTCoex], Coex Mechanism Init!!\n");
3301 halbtc8192e2ant_init_coex_dm(btcoexist);
3302 }
3303
3304 void ex_halbtc8192e2ant_display_coex_info(struct btc_coexist *btcoexist)
3305 {
3306 struct btc_board_info *board_info = &btcoexist->board_info;
3307 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3308 struct rtl_priv *rtlpriv = btcoexist->adapter;
3309 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3310 u16 u16tmp[4];
3311 u32 u32tmp[4];
3312 bool roam = false, scan = false, link = false, wifi_under_5g = false;
3313 bool bt_hson = false, wifi_busy = false;
3314 int wifirssi = 0, bt_hs_rssi = 0;
3315 u32 wifi_bw, wifi_traffic_dir;
3316 u8 wifi_dot11_chnl, wifi_hs_chnl;
3317 u32 fw_ver = 0, bt_patch_ver = 0;
3318
3319 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3320 "\r\n ============[BT Coexist info]============");
3321
3322 if (btcoexist->manual_control) {
3323 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3324 "\r\n ===========[Under Manual Control]===========");
3325 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3326 "\r\n ==========================================");
3327 }
3328
3329 if (!board_info->bt_exist) {
3330 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3331 return;
3332 }
3333
3334 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3335 "\r\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:",
3336 board_info->pg_ant_num, board_info->btdm_ant_num);
3337
3338 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
3339 "BT stack/ hci ext ver",
3340 ((stack_info->profile_notified) ? "Yes" : "No"),
3341 stack_info->hci_version);
3342
3343 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3344 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3345 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3346 "\r\n %-35s = %d_%d/ 0x%x/ 0x%x(%d)",
3347 "CoexVer/ FwVer/ PatchVer",
3348 glcoex_ver_date_8192e_2ant, glcoex_ver_8192e_2ant,
3349 fw_ver, bt_patch_ver, bt_patch_ver);
3350
3351 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hson);
3352 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3353 &wifi_dot11_chnl);
3354 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3355 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
3356 "Dot11 channel / HsMode(HsChnl)",
3357 wifi_dot11_chnl, bt_hson, wifi_hs_chnl);
3358
3359 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %3ph ",
3360 "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info);
3361
3362 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifirssi);
3363 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3364 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3365 "Wifi rssi/ HS rssi", wifirssi, bt_hs_rssi);
3366
3367 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3368 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3369 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3370 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3371 "Wifi link/ roam/ scan", link, roam, scan);
3372
3373 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3374 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3375 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3376 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3377 &wifi_traffic_dir);
3378 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
3379 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3380 ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3381 (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3382 ((!wifi_busy) ? "idle" :
3383 ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3384 "uplink" : "downlink")));
3385
3386 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = [%s/ %d/ %d] ",
3387 "BT [status/ rssi/ retryCnt]",
3388 ((btcoexist->bt_info.bt_disabled) ? ("disabled") :
3389 ((coex_sta->c2h_bt_inquiry_page) ?
3390 ("inquiry/page scan") :
3391 ((BT_8192E_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3392 coex_dm->bt_status) ? "non-connected idle" :
3393 ((BT_8192E_2ANT_BT_STATUS_CONNECTED_IDLE ==
3394 coex_dm->bt_status) ? "connected-idle" : "busy")))),
3395 coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
3396
3397 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d",
3398 "SCO/HID/PAN/A2DP", stack_info->sco_exist,
3399 stack_info->hid_exist, stack_info->pan_exist,
3400 stack_info->a2dp_exist);
3401 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3402
3403 bt_info_ext = coex_sta->bt_info_ext;
3404 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3405 "BT Info A2DP rate",
3406 (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3407
3408 for (i = 0; i < BT_INFO_SRC_8192E_2ANT_MAX; i++) {
3409 if (coex_sta->bt_info_c2h_cnt[i]) {
3410 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3411 "\r\n %-35s = %7ph(%d)",
3412 GLBtInfoSrc8192e2Ant[i],
3413 coex_sta->bt_info_c2h[i],
3414 coex_sta->bt_info_c2h_cnt[i]);
3415 }
3416 }
3417
3418 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3419 "PS state, IPS/LPS",
3420 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3421 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3422 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3423
3424 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x ", "SS Type",
3425 coex_dm->cur_sstype);
3426
3427 /* Sw mechanism */
3428 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3429 "============[Sw mechanism]============");
3430 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3431 "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3432 coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3433 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3434 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3435 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3436 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3437
3438 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x ", "Rate Mask",
3439 btcoexist->bt_info.ra_mask);
3440
3441 /* Fw mechanism */
3442 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3443 "============[Fw mechanism]============");
3444
3445 ps_tdma_case = coex_dm->cur_ps_tdma;
3446 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3447 "\r\n %-35s = %5ph case-%d (auto:%d)",
3448 "PS TDMA", coex_dm->ps_tdma_para,
3449 ps_tdma_case, coex_dm->auto_tdma_adjust);
3450
3451 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3452 "DecBtPwr/ IgnWlanAct",
3453 coex_dm->cur_dec_bt_pwr, coex_dm->cur_ignore_wlan_act);
3454
3455 /* Hw setting */
3456 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3457 "============[Hw setting]============");
3458
3459 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3460 "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3461
3462 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
3463 "backup ARFR1/ARFR2/RL/AMaxTime", coex_dm->backup_arfr_cnt1,
3464 coex_dm->backup_arfr_cnt2, coex_dm->backup_retrylimit,
3465 coex_dm->backup_ampdu_maxtime);
3466
3467 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
3468 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
3469 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
3470 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
3471 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
3472 "0x430/0x434/0x42a/0x456",
3473 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
3474
3475 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc04);
3476 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xd04);
3477 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x90c);
3478 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3479 "0xc04/ 0xd04/ 0x90c", u32tmp[0], u32tmp[1], u32tmp[2]);
3480
3481 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3482 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x", "0x778",
3483 u8tmp[0]);
3484
3485 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x92c);
3486 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3487 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3488 "0x92c/ 0x930", (u8tmp[0]), u32tmp[0]);
3489
3490 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3491 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x4f);
3492 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3493 "0x40/ 0x4f", u8tmp[0], u8tmp[1]);
3494
3495 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3496 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3497 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3498 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3499
3500 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3501 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x", "0xc50(dig)",
3502 u32tmp[0]);
3503
3504 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3505 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3506 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3507 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3508 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3509 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3510 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3511 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3512
3513 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3514 "0x770(hp rx[31:16]/tx[15:0])",
3515 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3516 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3517 "0x774(lp rx[31:16]/tx[15:0])",
3518 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
3519 #if (BT_AUTO_REPORT_ONLY_8192E_2ANT == 1)
3520 halbtc8192e2ant_monitor_bt_ctr(btcoexist);
3521 #endif
3522 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
3523 }
3524
3525 void ex_halbtc8192e2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3526 {
3527 if (BTC_IPS_ENTER == type) {
3528 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3529 "[BTCoex], IPS ENTER notify\n");
3530 coex_sta->under_ips = true;
3531 halbtc8192e2ant_coex_alloff(btcoexist);
3532 } else if (BTC_IPS_LEAVE == type) {
3533 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3534 "[BTCoex], IPS LEAVE notify\n");
3535 coex_sta->under_ips = false;
3536 }
3537 }
3538
3539 void ex_halbtc8192e2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3540 {
3541 if (BTC_LPS_ENABLE == type) {
3542 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3543 "[BTCoex], LPS ENABLE notify\n");
3544 coex_sta->under_lps = true;
3545 } else if (BTC_LPS_DISABLE == type) {
3546 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3547 "[BTCoex], LPS DISABLE notify\n");
3548 coex_sta->under_lps = false;
3549 }
3550 }
3551
3552 void ex_halbtc8192e2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3553 {
3554 if (BTC_SCAN_START == type)
3555 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3556 "[BTCoex], SCAN START notify\n");
3557 else if (BTC_SCAN_FINISH == type)
3558 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3559 "[BTCoex], SCAN FINISH notify\n");
3560 }
3561
3562 void ex_halbtc8192e2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3563 {
3564 if (BTC_ASSOCIATE_START == type)
3565 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3566 "[BTCoex], CONNECT START notify\n");
3567 else if (BTC_ASSOCIATE_FINISH == type)
3568 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3569 "[BTCoex], CONNECT FINISH notify\n");
3570 }
3571
3572 void ex_halbtc8192e2ant_media_status_notify(struct btc_coexist *btcoexist,
3573 u8 type)
3574 {
3575 u8 h2c_parameter[3] = {0};
3576 u32 wifi_bw;
3577 u8 wifi_center_chnl;
3578
3579 if (btcoexist->manual_control ||
3580 btcoexist->stop_coex_dm ||
3581 btcoexist->bt_info.bt_disabled)
3582 return;
3583
3584 if (BTC_MEDIA_CONNECT == type)
3585 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3586 "[BTCoex], MEDIA connect notify\n");
3587 else
3588 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3589 "[BTCoex], MEDIA disconnect notify\n");
3590
3591 /* only 2.4G we need to inform bt the chnl mask */
3592 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
3593 &wifi_center_chnl);
3594 if ((BTC_MEDIA_CONNECT == type) &&
3595 (wifi_center_chnl <= 14)) {
3596 h2c_parameter[0] = 0x1;
3597 h2c_parameter[1] = wifi_center_chnl;
3598 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3599 if (BTC_WIFI_BW_HT40 == wifi_bw)
3600 h2c_parameter[2] = 0x30;
3601 else
3602 h2c_parameter[2] = 0x20;
3603 }
3604
3605 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3606 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3607 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3608
3609 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
3610 "[BTCoex], FW write 0x66 = 0x%x\n",
3611 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3612 h2c_parameter[2]);
3613
3614 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3615 }
3616
3617 void ex_halbtc8192e2ant_special_packet_notify(struct btc_coexist *btcoexist,
3618 u8 type)
3619 {
3620 if (type == BTC_PACKET_DHCP)
3621 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3622 "[BTCoex], DHCP Packet notify\n");
3623 }
3624
3625 void ex_halbtc8192e2ant_bt_info_notify(struct btc_coexist *btcoexist,
3626 u8 *tmp_buf, u8 length)
3627 {
3628 u8 bt_info = 0;
3629 u8 i, rsp_source = 0;
3630 bool bt_busy = false, limited_dig = false;
3631 bool wifi_connected = false;
3632
3633 coex_sta->c2h_bt_info_req_sent = false;
3634
3635 rsp_source = tmp_buf[0] & 0xf;
3636 if (rsp_source >= BT_INFO_SRC_8192E_2ANT_MAX)
3637 rsp_source = BT_INFO_SRC_8192E_2ANT_WIFI_FW;
3638 coex_sta->bt_info_c2h_cnt[rsp_source]++;
3639
3640 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3641 "[BTCoex], Bt info[%d], length=%d, hex data = [",
3642 rsp_source, length);
3643 for (i = 0; i < length; i++) {
3644 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3645 if (i == 1)
3646 bt_info = tmp_buf[i];
3647 if (i == length-1)
3648 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3649 "0x%02x]\n", tmp_buf[i]);
3650 else
3651 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3652 "0x%02x, ", tmp_buf[i]);
3653 }
3654
3655 if (BT_INFO_SRC_8192E_2ANT_WIFI_FW != rsp_source) {
3656 coex_sta->bt_retry_cnt = /* [3:0] */
3657 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3658
3659 coex_sta->bt_rssi =
3660 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
3661
3662 coex_sta->bt_info_ext =
3663 coex_sta->bt_info_c2h[rsp_source][4];
3664
3665 /* Here we need to resend some wifi info to BT
3666 * because bt is reset and loss of the info.
3667 */
3668 if ((coex_sta->bt_info_ext & BIT1)) {
3669 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3670 "bit1, send wifi BW&Chnl to BT!!\n");
3671 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3672 &wifi_connected);
3673 if (wifi_connected)
3674 ex_halbtc8192e2ant_media_status_notify(
3675 btcoexist,
3676 BTC_MEDIA_CONNECT);
3677 else
3678 ex_halbtc8192e2ant_media_status_notify(
3679 btcoexist,
3680 BTC_MEDIA_DISCONNECT);
3681 }
3682
3683 if ((coex_sta->bt_info_ext & BIT3)) {
3684 if (!btcoexist->manual_control &&
3685 !btcoexist->stop_coex_dm) {
3686 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3687 "bit3, BT NOT ignore Wlan active!\n");
3688 halbtc8192e2ant_IgnoreWlanAct(btcoexist,
3689 FORCE_EXEC,
3690 false);
3691 }
3692 } else {
3693 /* BT already NOT ignore Wlan active,
3694 * do nothing here.
3695 */
3696 }
3697
3698 #if (BT_AUTO_REPORT_ONLY_8192E_2ANT == 0)
3699 if ((coex_sta->bt_info_ext & BIT4)) {
3700 /* BT auto report already enabled, do nothing */
3701 } else {
3702 halbtc8192e2ant_bt_autoreport(btcoexist, FORCE_EXEC,
3703 true);
3704 }
3705 #endif
3706 }
3707
3708 /* check BIT2 first ==> check if bt is under inquiry or page scan */
3709 if (bt_info & BT_INFO_8192E_2ANT_B_INQ_PAGE)
3710 coex_sta->c2h_bt_inquiry_page = true;
3711 else
3712 coex_sta->c2h_bt_inquiry_page = false;
3713
3714 /* set link exist status */
3715 if (!(bt_info&BT_INFO_8192E_2ANT_B_CONNECTION)) {
3716 coex_sta->bt_link_exist = false;
3717 coex_sta->pan_exist = false;
3718 coex_sta->a2dp_exist = false;
3719 coex_sta->hid_exist = false;
3720 coex_sta->sco_exist = false;
3721 } else {/* connection exists */
3722 coex_sta->bt_link_exist = true;
3723 if (bt_info & BT_INFO_8192E_2ANT_B_FTP)
3724 coex_sta->pan_exist = true;
3725 else
3726 coex_sta->pan_exist = false;
3727 if (bt_info & BT_INFO_8192E_2ANT_B_A2DP)
3728 coex_sta->a2dp_exist = true;
3729 else
3730 coex_sta->a2dp_exist = false;
3731 if (bt_info & BT_INFO_8192E_2ANT_B_HID)
3732 coex_sta->hid_exist = true;
3733 else
3734 coex_sta->hid_exist = false;
3735 if (bt_info & BT_INFO_8192E_2ANT_B_SCO_ESCO)
3736 coex_sta->sco_exist = true;
3737 else
3738 coex_sta->sco_exist = false;
3739 }
3740
3741 halbtc8192e2ant_update_btlink_info(btcoexist);
3742
3743 if (!(bt_info&BT_INFO_8192E_2ANT_B_CONNECTION)) {
3744 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3745 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3746 "[BTCoex], BT Non-Connected idle!!!\n");
3747 } else if (bt_info == BT_INFO_8192E_2ANT_B_CONNECTION) {
3748 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_CONNECTED_IDLE;
3749 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3750 "[BTCoex], bt_infoNotify(), BT Connected-idle!!!\n");
3751 } else if ((bt_info&BT_INFO_8192E_2ANT_B_SCO_ESCO) ||
3752 (bt_info&BT_INFO_8192E_2ANT_B_SCO_BUSY)) {
3753 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_SCO_BUSY;
3754 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3755 "[BTCoex], bt_infoNotify(), BT SCO busy!!!\n");
3756 } else if (bt_info&BT_INFO_8192E_2ANT_B_ACL_BUSY) {
3757 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_ACL_BUSY;
3758 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3759 "[BTCoex], bt_infoNotify(), BT ACL busy!!!\n");
3760 } else {
3761 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_MAX;
3762 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3763 "[BTCoex]bt_infoNotify(), BT Non-Defined state!!!\n");
3764 }
3765
3766 if ((BT_8192E_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3767 (BT_8192E_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3768 (BT_8192E_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
3769 bt_busy = true;
3770 limited_dig = true;
3771 } else {
3772 bt_busy = false;
3773 limited_dig = false;
3774 }
3775
3776 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3777
3778 coex_dm->limited_dig = limited_dig;
3779 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
3780
3781 halbtc8192e2ant_run_coexist_mechanism(btcoexist);
3782 }
3783
3784 void ex_halbtc8192e2ant_stack_operation_notify(struct btc_coexist *btcoexist,
3785 u8 type)
3786 {
3787 }
3788
3789 void ex_halbtc8192e2ant_halt_notify(struct btc_coexist *btcoexist)
3790 {
3791 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
3792
3793 halbtc8192e2ant_IgnoreWlanAct(btcoexist, FORCE_EXEC, true);
3794 ex_halbtc8192e2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3795 }
3796
3797 void ex_halbtc8192e2ant_periodical(struct btc_coexist *btcoexist)
3798 {
3799 static u8 dis_ver_info_cnt;
3800 u32 fw_ver = 0, bt_patch_ver = 0;
3801 struct btc_board_info *board_info = &btcoexist->board_info;
3802 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3803
3804 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3805 "=======================Periodical=======================\n");
3806 if (dis_ver_info_cnt <= 5) {
3807 dis_ver_info_cnt += 1;
3808 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3809 "************************************************\n");
3810 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3811 "Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
3812 board_info->pg_ant_num, board_info->btdm_ant_num,
3813 board_info->btdm_ant_pos);
3814 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3815 "BT stack/ hci ext ver = %s / %d\n",
3816 ((stack_info->profile_notified) ? "Yes" : "No"),
3817 stack_info->hci_version);
3818 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3819 &bt_patch_ver);
3820 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3821 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3822 "CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3823 glcoex_ver_date_8192e_2ant, glcoex_ver_8192e_2ant,
3824 fw_ver, bt_patch_ver, bt_patch_ver);
3825 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3826 "************************************************\n");
3827 }
3828
3829 #if (BT_AUTO_REPORT_ONLY_8192E_2ANT == 0)
3830 halbtc8192e2ant_querybt_info(btcoexist);
3831 halbtc8192e2ant_monitor_bt_ctr(btcoexist);
3832 btc8192e2ant_monitor_bt_enable_dis(btcoexist);
3833 #else
3834 if (halbtc8192e2ant_iswifi_status_changed(btcoexist) ||
3835 coex_dm->auto_tdma_adjust)
3836 halbtc8192e2ant_run_coexist_mechanism(btcoexist);
3837 #endif
3838 }
Linux with added FPC-III support