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