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