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