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 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1295 0x3, 0xf1, 0x90);
1296 break;
1297 case 4:
1298 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1299 0x03, 0xf1, 0x90);
1300 break;
1301 case 5:
1302 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1303 0x1a, 0x60, 0x90);
1304 break;
1305 case 6:
1306 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1307 0x12, 0x60, 0x90);
1308 break;
1309 case 7:
1310 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1311 0x3, 0x70, 0x90);
1312 break;
1313 case 8:
1314 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1315 0x3, 0x70, 0x90);
1316 break;
1317 case 9:
1318 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1319 0x1a, 0xe1, 0x90);
1320 break;
1321 case 10:
1322 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1323 0x12, 0xe1, 0x90);
1324 break;
1325 case 11:
1326 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1327 0xa, 0xe1, 0x90);
1328 break;
1329 case 12:
1330 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1331 0x5, 0xe1, 0x90);
1332 break;
1333 case 13:
1334 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1335 0x1a, 0x60, 0x90);
1336 break;
1337 case 14:
1338 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1339 0x12, 0x60, 0x90);
1340 break;
1341 case 15:
1342 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1343 0xa, 0x60, 0x90);
1344 break;
1345 case 16:
1346 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1347 0x5, 0x60, 0x90);
1348 break;
1349 case 17:
1350 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1351 0x2f, 0x60, 0x90);
1352 break;
1353 case 18:
1354 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1355 0x5, 0xe1, 0x90);
1356 break;
1357 case 19:
1358 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1359 0x25, 0xe1, 0x90);
1360 break;
1361 case 20:
1362 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1363 0x25, 0x60, 0x90);
1364 break;
1365 case 21:
1366 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1367 0x03, 0x70, 0x90);
1368 break;
1369 case 71:
1370 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1371 0x1a, 0xe1, 0x90);
1372 break;
1373 }
1374 } else {
1375 /* disable PS tdma */
1376 switch (type) {
1377 case 0:
1378 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1379 0x40, 0x0);
1380 break;
1381 case 1:
1382 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1383 0x48, 0x0);
1384 break;
1385 default:
1386 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1387 0x40, 0x0);
1388 break;
1389 }
1390 }
1391
1392 /* update pre state */
1393 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1394 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1395 }
1396
btc8723b2ant_coex_alloff(struct btc_coexist * btcoexist)1397 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1398 {
1399 /* fw all off */
1400 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1401 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1402 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1403
1404 /* sw all off */
1405 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1406 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1407
1408 /* hw all off */
1409 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1410 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1411 }
1412
btc8723b2ant_init_coex_dm(struct btc_coexist * btcoexist)1413 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1414 {
1415 /* force to reset coex mechanism*/
1416
1417 btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1418 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1419 btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, false);
1420
1421 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1422 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1423 }
1424
btc8723b2ant_action_bt_inquiry(struct btc_coexist * btcoexist)1425 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1426 {
1427 bool wifi_connected = false;
1428 bool low_pwr_disable = true;
1429
1430 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1431 &low_pwr_disable);
1432 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1433 &wifi_connected);
1434
1435 if (wifi_connected) {
1436 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
1437 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1438 } else {
1439 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1440 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1441 }
1442 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1443 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1444
1445 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1446 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1447
1448 coex_dm->need_recover_0x948 = true;
1449 coex_dm->backup_0x948 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1450
1451 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_AUX,
1452 false, false);
1453 }
1454
btc8723b2ant_is_common_action(struct btc_coexist * btcoexist)1455 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1456 {
1457 bool common = false, wifi_connected = false;
1458 bool wifi_busy = false;
1459 bool bt_hs_on = false, low_pwr_disable = false;
1460
1461 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1462 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1463 &wifi_connected);
1464 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1465
1466 if (!wifi_connected) {
1467 low_pwr_disable = false;
1468 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1469 &low_pwr_disable);
1470
1471 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1472 "[BTCoex], Wifi non-connected idle!!\n");
1473
1474 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1475 0x0);
1476 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1477 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1478 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1479 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1480
1481 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false,
1482 false);
1483 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false,
1484 0x18);
1485
1486 common = true;
1487 } else {
1488 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1489 coex_dm->bt_status) {
1490 low_pwr_disable = false;
1491 btcoexist->btc_set(btcoexist,
1492 BTC_SET_ACT_DISABLE_LOW_POWER,
1493 &low_pwr_disable);
1494
1495 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1496 "[BTCoex], Wifi connected + "
1497 "BT non connected-idle!!\n");
1498
1499 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1500 0xfffff, 0x0);
1501 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1502 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1503 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1504 0xb);
1505 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1506 false);
1507
1508 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
1509 false, false);
1510 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1511 false, 0x18);
1512
1513 common = true;
1514 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1515 coex_dm->bt_status) {
1516 low_pwr_disable = true;
1517 btcoexist->btc_set(btcoexist,
1518 BTC_SET_ACT_DISABLE_LOW_POWER,
1519 &low_pwr_disable);
1520
1521 if (bt_hs_on)
1522 return false;
1523 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1524 "[BTCoex], Wifi connected + "
1525 "BT connected-idle!!\n");
1526
1527 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1528 0xfffff, 0x0);
1529 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1530 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1531 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1532 0xb);
1533 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1534 false);
1535
1536 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
1537 false, false);
1538 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1539 false, 0x18);
1540
1541 common = true;
1542 } else {
1543 low_pwr_disable = true;
1544 btcoexist->btc_set(btcoexist,
1545 BTC_SET_ACT_DISABLE_LOW_POWER,
1546 &low_pwr_disable);
1547
1548 if (wifi_busy) {
1549 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1550 "[BTCoex], Wifi Connected-Busy + "
1551 "BT Busy!!\n");
1552 common = false;
1553 } else {
1554 if (bt_hs_on)
1555 return false;
1556
1557 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1558 "[BTCoex], Wifi Connected-Idle + "
1559 "BT Busy!!\n");
1560
1561 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1562 0x1, 0xfffff, 0x0);
1563 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC,
1564 7);
1565 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1566 true, 21);
1567 btc8723b2ant_fw_dac_swing_lvl(btcoexist,
1568 NORMAL_EXEC,
1569 0xb);
1570 if (btc8723b_need_dec_pwr(btcoexist))
1571 btc8723b2ant_dec_bt_pwr(btcoexist,
1572 NORMAL_EXEC,
1573 true);
1574 else
1575 btc8723b2ant_dec_bt_pwr(btcoexist,
1576 NORMAL_EXEC,
1577 false);
1578 btc8723b2ant_sw_mechanism1(btcoexist, false,
1579 false, false,
1580 false);
1581 btc8723b2ant_sw_mechanism2(btcoexist, false,
1582 false, false,
1583 0x18);
1584 common = true;
1585 }
1586 }
1587 }
1588
1589 return common;
1590 }
1591
set_tdma_int1(struct btc_coexist * btcoexist,bool tx_pause,s32 result)1592 static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause,
1593 s32 result)
1594 {
1595 /* Set PS TDMA for max interval == 1 */
1596 if (tx_pause) {
1597 BTC_PRINT(BTC_MSG_ALGORITHM,
1598 ALGO_TRACE_FW_DETAIL,
1599 "[BTCoex], TxPause = 1\n");
1600
1601 if (coex_dm->cur_ps_tdma == 71) {
1602 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1603 true, 5);
1604 coex_dm->tdma_adj_type = 5;
1605 } else if (coex_dm->cur_ps_tdma == 1) {
1606 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1607 true, 5);
1608 coex_dm->tdma_adj_type = 5;
1609 } else if (coex_dm->cur_ps_tdma == 2) {
1610 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1611 true, 6);
1612 coex_dm->tdma_adj_type = 6;
1613 } else if (coex_dm->cur_ps_tdma == 3) {
1614 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1615 true, 7);
1616 coex_dm->tdma_adj_type = 7;
1617 } else if (coex_dm->cur_ps_tdma == 4) {
1618 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1619 true, 8);
1620 coex_dm->tdma_adj_type = 8;
1621 }
1622
1623 if (coex_dm->cur_ps_tdma == 9) {
1624 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1625 true, 13);
1626 coex_dm->tdma_adj_type = 13;
1627 } else if (coex_dm->cur_ps_tdma == 10) {
1628 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1629 true, 14);
1630 coex_dm->tdma_adj_type = 14;
1631 } else if (coex_dm->cur_ps_tdma == 11) {
1632 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1633 true, 15);
1634 coex_dm->tdma_adj_type = 15;
1635 } else if (coex_dm->cur_ps_tdma == 12) {
1636 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1637 true, 16);
1638 coex_dm->tdma_adj_type = 16;
1639 }
1640
1641 if (result == -1) {
1642 if (coex_dm->cur_ps_tdma == 5) {
1643 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1644 true, 6);
1645 coex_dm->tdma_adj_type = 6;
1646 } else if (coex_dm->cur_ps_tdma == 6) {
1647 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1648 true, 7);
1649 coex_dm->tdma_adj_type = 7;
1650 } else if (coex_dm->cur_ps_tdma == 7) {
1651 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1652 true, 8);
1653 coex_dm->tdma_adj_type = 8;
1654 } else if (coex_dm->cur_ps_tdma == 13) {
1655 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1656 true, 14);
1657 coex_dm->tdma_adj_type = 14;
1658 } else if (coex_dm->cur_ps_tdma == 14) {
1659 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1660 true, 15);
1661 coex_dm->tdma_adj_type = 15;
1662 } else if (coex_dm->cur_ps_tdma == 15) {
1663 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1664 true, 16);
1665 coex_dm->tdma_adj_type = 16;
1666 }
1667 } else if (result == 1) {
1668 if (coex_dm->cur_ps_tdma == 8) {
1669 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1670 true, 7);
1671 coex_dm->tdma_adj_type = 7;
1672 } else if (coex_dm->cur_ps_tdma == 7) {
1673 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1674 true, 6);
1675 coex_dm->tdma_adj_type = 6;
1676 } else if (coex_dm->cur_ps_tdma == 6) {
1677 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1678 true, 5);
1679 coex_dm->tdma_adj_type = 5;
1680 } else if (coex_dm->cur_ps_tdma == 16) {
1681 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1682 true, 15);
1683 coex_dm->tdma_adj_type = 15;
1684 } else if (coex_dm->cur_ps_tdma == 15) {
1685 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1686 true, 14);
1687 coex_dm->tdma_adj_type = 14;
1688 } else if (coex_dm->cur_ps_tdma == 14) {
1689 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1690 true, 13);
1691 coex_dm->tdma_adj_type = 13;
1692 }
1693 }
1694 } else {
1695 BTC_PRINT(BTC_MSG_ALGORITHM,
1696 ALGO_TRACE_FW_DETAIL,
1697 "[BTCoex], TxPause = 0\n");
1698 if (coex_dm->cur_ps_tdma == 5) {
1699 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 71);
1700 coex_dm->tdma_adj_type = 71;
1701 } else if (coex_dm->cur_ps_tdma == 6) {
1702 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1703 coex_dm->tdma_adj_type = 2;
1704 } else if (coex_dm->cur_ps_tdma == 7) {
1705 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1706 coex_dm->tdma_adj_type = 3;
1707 } else if (coex_dm->cur_ps_tdma == 8) {
1708 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1709 coex_dm->tdma_adj_type = 4;
1710 }
1711
1712 if (coex_dm->cur_ps_tdma == 13) {
1713 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
1714 coex_dm->tdma_adj_type = 9;
1715 } else if (coex_dm->cur_ps_tdma == 14) {
1716 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1717 coex_dm->tdma_adj_type = 10;
1718 } else if (coex_dm->cur_ps_tdma == 15) {
1719 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1720 coex_dm->tdma_adj_type = 11;
1721 } else if (coex_dm->cur_ps_tdma == 16) {
1722 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1723 coex_dm->tdma_adj_type = 12;
1724 }
1725
1726 if (result == -1) {
1727 if (coex_dm->cur_ps_tdma == 71) {
1728 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1729 true, 1);
1730 coex_dm->tdma_adj_type = 1;
1731 } else if (coex_dm->cur_ps_tdma == 1) {
1732 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1733 true, 2);
1734 coex_dm->tdma_adj_type = 2;
1735 } else if (coex_dm->cur_ps_tdma == 2) {
1736 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1737 true, 3);
1738 coex_dm->tdma_adj_type = 3;
1739 } else if (coex_dm->cur_ps_tdma == 3) {
1740 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1741 true, 4);
1742 coex_dm->tdma_adj_type = 4;
1743 } else if (coex_dm->cur_ps_tdma == 9) {
1744 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1745 true, 10);
1746 coex_dm->tdma_adj_type = 10;
1747 } else if (coex_dm->cur_ps_tdma == 10) {
1748 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1749 true, 11);
1750 coex_dm->tdma_adj_type = 11;
1751 } else if (coex_dm->cur_ps_tdma == 11) {
1752 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1753 true, 12);
1754 coex_dm->tdma_adj_type = 12;
1755 }
1756 } else if (result == 1) {
1757 if (coex_dm->cur_ps_tdma == 4) {
1758 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1759 true, 3);
1760 coex_dm->tdma_adj_type = 3;
1761 } else if (coex_dm->cur_ps_tdma == 3) {
1762 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1763 true, 2);
1764 coex_dm->tdma_adj_type = 2;
1765 } else if (coex_dm->cur_ps_tdma == 2) {
1766 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1767 true, 1);
1768 coex_dm->tdma_adj_type = 1;
1769 } else if (coex_dm->cur_ps_tdma == 1) {
1770 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1771 true, 71);
1772 coex_dm->tdma_adj_type = 71;
1773 } else if (coex_dm->cur_ps_tdma == 12) {
1774 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1775 true, 11);
1776 coex_dm->tdma_adj_type = 11;
1777 } else if (coex_dm->cur_ps_tdma == 11) {
1778 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1779 true, 10);
1780 coex_dm->tdma_adj_type = 10;
1781 } else if (coex_dm->cur_ps_tdma == 10) {
1782 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1783 true, 9);
1784 coex_dm->tdma_adj_type = 9;
1785 }
1786 }
1787 }
1788 }
1789
set_tdma_int2(struct btc_coexist * btcoexist,bool tx_pause,s32 result)1790 static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause,
1791 s32 result)
1792 {
1793 /* Set PS TDMA for max interval == 2 */
1794 if (tx_pause) {
1795 BTC_PRINT(BTC_MSG_ALGORITHM,
1796 ALGO_TRACE_FW_DETAIL,
1797 "[BTCoex], TxPause = 1\n");
1798 if (coex_dm->cur_ps_tdma == 1) {
1799 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1800 coex_dm->tdma_adj_type = 6;
1801 } else if (coex_dm->cur_ps_tdma == 2) {
1802 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1803 coex_dm->tdma_adj_type = 6;
1804 } else if (coex_dm->cur_ps_tdma == 3) {
1805 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1806 coex_dm->tdma_adj_type = 7;
1807 } else if (coex_dm->cur_ps_tdma == 4) {
1808 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1809 coex_dm->tdma_adj_type = 8;
1810 }
1811 if (coex_dm->cur_ps_tdma == 9) {
1812 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1813 coex_dm->tdma_adj_type = 14;
1814 } else if (coex_dm->cur_ps_tdma == 10) {
1815 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1816 coex_dm->tdma_adj_type = 14;
1817 } else if (coex_dm->cur_ps_tdma == 11) {
1818 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1819 coex_dm->tdma_adj_type = 15;
1820 } else if (coex_dm->cur_ps_tdma == 12) {
1821 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1822 coex_dm->tdma_adj_type = 16;
1823 }
1824 if (result == -1) {
1825 if (coex_dm->cur_ps_tdma == 5) {
1826 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1827 true, 6);
1828 coex_dm->tdma_adj_type = 6;
1829 } else if (coex_dm->cur_ps_tdma == 6) {
1830 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1831 true, 7);
1832 coex_dm->tdma_adj_type = 7;
1833 } else if (coex_dm->cur_ps_tdma == 7) {
1834 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1835 true, 8);
1836 coex_dm->tdma_adj_type = 8;
1837 } else if (coex_dm->cur_ps_tdma == 13) {
1838 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1839 true, 14);
1840 coex_dm->tdma_adj_type = 14;
1841 } else if (coex_dm->cur_ps_tdma == 14) {
1842 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1843 true, 15);
1844 coex_dm->tdma_adj_type = 15;
1845 } else if (coex_dm->cur_ps_tdma == 15) {
1846 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1847 true, 16);
1848 coex_dm->tdma_adj_type = 16;
1849 }
1850 } else if (result == 1) {
1851 if (coex_dm->cur_ps_tdma == 8) {
1852 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1853 true, 7);
1854 coex_dm->tdma_adj_type = 7;
1855 } else if (coex_dm->cur_ps_tdma == 7) {
1856 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1857 true, 6);
1858 coex_dm->tdma_adj_type = 6;
1859 } else if (coex_dm->cur_ps_tdma == 6) {
1860 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1861 true, 6);
1862 coex_dm->tdma_adj_type = 6;
1863 } else if (coex_dm->cur_ps_tdma == 16) {
1864 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1865 true, 15);
1866 coex_dm->tdma_adj_type = 15;
1867 } else if (coex_dm->cur_ps_tdma == 15) {
1868 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1869 true, 14);
1870 coex_dm->tdma_adj_type = 14;
1871 } else if (coex_dm->cur_ps_tdma == 14) {
1872 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1873 true, 14);
1874 coex_dm->tdma_adj_type = 14;
1875 }
1876 }
1877 } else {
1878 BTC_PRINT(BTC_MSG_ALGORITHM,
1879 ALGO_TRACE_FW_DETAIL,
1880 "[BTCoex], TxPause = 0\n");
1881 if (coex_dm->cur_ps_tdma == 5) {
1882 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1883 coex_dm->tdma_adj_type = 2;
1884 } else if (coex_dm->cur_ps_tdma == 6) {
1885 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1886 coex_dm->tdma_adj_type = 2;
1887 } else if (coex_dm->cur_ps_tdma == 7) {
1888 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1889 coex_dm->tdma_adj_type = 3;
1890 } else if (coex_dm->cur_ps_tdma == 8) {
1891 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1892 coex_dm->tdma_adj_type = 4;
1893 }
1894 if (coex_dm->cur_ps_tdma == 13) {
1895 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1896 coex_dm->tdma_adj_type = 10;
1897 } else if (coex_dm->cur_ps_tdma == 14) {
1898 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1899 coex_dm->tdma_adj_type = 10;
1900 } else if (coex_dm->cur_ps_tdma == 15) {
1901 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1902 coex_dm->tdma_adj_type = 11;
1903 } else if (coex_dm->cur_ps_tdma == 16) {
1904 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1905 coex_dm->tdma_adj_type = 12;
1906 }
1907 if (result == -1) {
1908 if (coex_dm->cur_ps_tdma == 1) {
1909 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1910 true, 2);
1911 coex_dm->tdma_adj_type = 2;
1912 } else if (coex_dm->cur_ps_tdma == 2) {
1913 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1914 true, 3);
1915 coex_dm->tdma_adj_type = 3;
1916 } else if (coex_dm->cur_ps_tdma == 3) {
1917 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1918 true, 4);
1919 coex_dm->tdma_adj_type = 4;
1920 } else if (coex_dm->cur_ps_tdma == 9) {
1921 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1922 true, 10);
1923 coex_dm->tdma_adj_type = 10;
1924 } else if (coex_dm->cur_ps_tdma == 10) {
1925 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1926 true, 11);
1927 coex_dm->tdma_adj_type = 11;
1928 } else if (coex_dm->cur_ps_tdma == 11) {
1929 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1930 true, 12);
1931 coex_dm->tdma_adj_type = 12;
1932 }
1933 } else if (result == 1) {
1934 if (coex_dm->cur_ps_tdma == 4) {
1935 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1936 true, 3);
1937 coex_dm->tdma_adj_type = 3;
1938 } else if (coex_dm->cur_ps_tdma == 3) {
1939 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1940 true, 2);
1941 coex_dm->tdma_adj_type = 2;
1942 } else if (coex_dm->cur_ps_tdma == 2) {
1943 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1944 true, 2);
1945 coex_dm->tdma_adj_type = 2;
1946 } else if (coex_dm->cur_ps_tdma == 12) {
1947 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1948 true, 11);
1949 coex_dm->tdma_adj_type = 11;
1950 } else if (coex_dm->cur_ps_tdma == 11) {
1951 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1952 true, 10);
1953 coex_dm->tdma_adj_type = 10;
1954 } else if (coex_dm->cur_ps_tdma == 10) {
1955 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1956 true, 10);
1957 coex_dm->tdma_adj_type = 10;
1958 }
1959 }
1960 }
1961 }
1962
set_tdma_int3(struct btc_coexist * btcoexist,bool tx_pause,s32 result)1963 static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause,
1964 s32 result)
1965 {
1966 /* Set PS TDMA for max interval == 3 */
1967 if (tx_pause) {
1968 BTC_PRINT(BTC_MSG_ALGORITHM,
1969 ALGO_TRACE_FW_DETAIL,
1970 "[BTCoex], TxPause = 1\n");
1971 if (coex_dm->cur_ps_tdma == 1) {
1972 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1973 coex_dm->tdma_adj_type = 7;
1974 } else if (coex_dm->cur_ps_tdma == 2) {
1975 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1976 coex_dm->tdma_adj_type = 7;
1977 } else if (coex_dm->cur_ps_tdma == 3) {
1978 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1979 coex_dm->tdma_adj_type = 7;
1980 } else if (coex_dm->cur_ps_tdma == 4) {
1981 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1982 coex_dm->tdma_adj_type = 8;
1983 }
1984 if (coex_dm->cur_ps_tdma == 9) {
1985 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1986 coex_dm->tdma_adj_type = 15;
1987 } else if (coex_dm->cur_ps_tdma == 10) {
1988 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1989 coex_dm->tdma_adj_type = 15;
1990 } else if (coex_dm->cur_ps_tdma == 11) {
1991 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1992 coex_dm->tdma_adj_type = 15;
1993 } else if (coex_dm->cur_ps_tdma == 12) {
1994 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1995 coex_dm->tdma_adj_type = 16;
1996 }
1997 if (result == -1) {
1998 if (coex_dm->cur_ps_tdma == 5) {
1999 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2000 true, 7);
2001 coex_dm->tdma_adj_type = 7;
2002 } else if (coex_dm->cur_ps_tdma == 6) {
2003 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2004 true, 7);
2005 coex_dm->tdma_adj_type = 7;
2006 } else if (coex_dm->cur_ps_tdma == 7) {
2007 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2008 true, 8);
2009 coex_dm->tdma_adj_type = 8;
2010 } else if (coex_dm->cur_ps_tdma == 13) {
2011 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2012 true, 15);
2013 coex_dm->tdma_adj_type = 15;
2014 } else if (coex_dm->cur_ps_tdma == 14) {
2015 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2016 true, 15);
2017 coex_dm->tdma_adj_type = 15;
2018 } else if (coex_dm->cur_ps_tdma == 15) {
2019 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2020 true, 16);
2021 coex_dm->tdma_adj_type = 16;
2022 }
2023 } else if (result == 1) {
2024 if (coex_dm->cur_ps_tdma == 8) {
2025 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2026 true, 7);
2027 coex_dm->tdma_adj_type = 7;
2028 } else if (coex_dm->cur_ps_tdma == 7) {
2029 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2030 true, 7);
2031 coex_dm->tdma_adj_type = 7;
2032 } else if (coex_dm->cur_ps_tdma == 6) {
2033 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2034 true, 7);
2035 coex_dm->tdma_adj_type = 7;
2036 } else if (coex_dm->cur_ps_tdma == 16) {
2037 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2038 true, 15);
2039 coex_dm->tdma_adj_type = 15;
2040 } else if (coex_dm->cur_ps_tdma == 15) {
2041 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2042 true, 15);
2043 coex_dm->tdma_adj_type = 15;
2044 } else if (coex_dm->cur_ps_tdma == 14) {
2045 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2046 true, 15);
2047 coex_dm->tdma_adj_type = 15;
2048 }
2049 }
2050 } else {
2051 BTC_PRINT(BTC_MSG_ALGORITHM,
2052 ALGO_TRACE_FW_DETAIL,
2053 "[BTCoex], TxPause = 0\n");
2054 if (coex_dm->cur_ps_tdma == 5) {
2055 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2056 coex_dm->tdma_adj_type = 3;
2057 } else if (coex_dm->cur_ps_tdma == 6) {
2058 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2059 coex_dm->tdma_adj_type = 3;
2060 } else if (coex_dm->cur_ps_tdma == 7) {
2061 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2062 coex_dm->tdma_adj_type = 3;
2063 } else if (coex_dm->cur_ps_tdma == 8) {
2064 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
2065 coex_dm->tdma_adj_type = 4;
2066 }
2067 if (coex_dm->cur_ps_tdma == 13) {
2068 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2069 coex_dm->tdma_adj_type = 11;
2070 } else if (coex_dm->cur_ps_tdma == 14) {
2071 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2072 coex_dm->tdma_adj_type = 11;
2073 } else if (coex_dm->cur_ps_tdma == 15) {
2074 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2075 coex_dm->tdma_adj_type = 11;
2076 } else if (coex_dm->cur_ps_tdma == 16) {
2077 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
2078 coex_dm->tdma_adj_type = 12;
2079 }
2080 if (result == -1) {
2081 if (coex_dm->cur_ps_tdma == 1) {
2082 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2083 true, 3);
2084 coex_dm->tdma_adj_type = 3;
2085 } else if (coex_dm->cur_ps_tdma == 2) {
2086 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2087 true, 3);
2088 coex_dm->tdma_adj_type = 3;
2089 } else if (coex_dm->cur_ps_tdma == 3) {
2090 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2091 true, 4);
2092 coex_dm->tdma_adj_type = 4;
2093 } else if (coex_dm->cur_ps_tdma == 9) {
2094 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2095 true, 11);
2096 coex_dm->tdma_adj_type = 11;
2097 } else if (coex_dm->cur_ps_tdma == 10) {
2098 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2099 true, 11);
2100 coex_dm->tdma_adj_type = 11;
2101 } else if (coex_dm->cur_ps_tdma == 11) {
2102 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2103 true, 12);
2104 coex_dm->tdma_adj_type = 12;
2105 }
2106 } else if (result == 1) {
2107 if (coex_dm->cur_ps_tdma == 4) {
2108 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2109 true, 3);
2110 coex_dm->tdma_adj_type = 3;
2111 } else if (coex_dm->cur_ps_tdma == 3) {
2112 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2113 true, 3);
2114 coex_dm->tdma_adj_type = 3;
2115 } else if (coex_dm->cur_ps_tdma == 2) {
2116 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2117 true, 3);
2118 coex_dm->tdma_adj_type = 3;
2119 } else if (coex_dm->cur_ps_tdma == 12) {
2120 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2121 true, 11);
2122 coex_dm->tdma_adj_type = 11;
2123 } else if (coex_dm->cur_ps_tdma == 11) {
2124 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2125 true, 11);
2126 coex_dm->tdma_adj_type = 11;
2127 } else if (coex_dm->cur_ps_tdma == 10) {
2128 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2129 true, 11);
2130 coex_dm->tdma_adj_type = 11;
2131 }
2132 }
2133 }
2134 }
2135
btc8723b2ant_tdma_duration_adjust(struct btc_coexist * btcoexist,bool sco_hid,bool tx_pause,u8 max_interval)2136 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
2137 bool sco_hid, bool tx_pause,
2138 u8 max_interval)
2139 {
2140 static s32 up, dn, m, n, wait_count;
2141 /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
2142 s32 result;
2143 u8 retry_count = 0;
2144
2145 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
2146 "[BTCoex], TdmaDurationAdjust()\n");
2147
2148 if (!coex_dm->auto_tdma_adjust) {
2149 coex_dm->auto_tdma_adjust = true;
2150 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2151 "[BTCoex], first run TdmaDurationAdjust()!!\n");
2152 if (sco_hid) {
2153 if (tx_pause) {
2154 if (max_interval == 1) {
2155 btc8723b2ant_ps_tdma(btcoexist,
2156 NORMAL_EXEC,
2157 true, 13);
2158 coex_dm->tdma_adj_type = 13;
2159 } else if (max_interval == 2) {
2160 btc8723b2ant_ps_tdma(btcoexist,
2161 NORMAL_EXEC,
2162 true, 14);
2163 coex_dm->tdma_adj_type = 14;
2164 } else if (max_interval == 3) {
2165 btc8723b2ant_ps_tdma(btcoexist,
2166 NORMAL_EXEC,
2167 true, 15);
2168 coex_dm->tdma_adj_type = 15;
2169 } else {
2170 btc8723b2ant_ps_tdma(btcoexist,
2171 NORMAL_EXEC,
2172 true, 15);
2173 coex_dm->tdma_adj_type = 15;
2174 }
2175 } else {
2176 if (max_interval == 1) {
2177 btc8723b2ant_ps_tdma(btcoexist,
2178 NORMAL_EXEC,
2179 true, 9);
2180 coex_dm->tdma_adj_type = 9;
2181 } else if (max_interval == 2) {
2182 btc8723b2ant_ps_tdma(btcoexist,
2183 NORMAL_EXEC,
2184 true, 10);
2185 coex_dm->tdma_adj_type = 10;
2186 } else if (max_interval == 3) {
2187 btc8723b2ant_ps_tdma(btcoexist,
2188 NORMAL_EXEC,
2189 true, 11);
2190 coex_dm->tdma_adj_type = 11;
2191 } else {
2192 btc8723b2ant_ps_tdma(btcoexist,
2193 NORMAL_EXEC,
2194 true, 11);
2195 coex_dm->tdma_adj_type = 11;
2196 }
2197 }
2198 } else {
2199 if (tx_pause) {
2200 if (max_interval == 1) {
2201 btc8723b2ant_ps_tdma(btcoexist,
2202 NORMAL_EXEC,
2203 true, 5);
2204 coex_dm->tdma_adj_type = 5;
2205 } else if (max_interval == 2) {
2206 btc8723b2ant_ps_tdma(btcoexist,
2207 NORMAL_EXEC,
2208 true, 6);
2209 coex_dm->tdma_adj_type = 6;
2210 } else if (max_interval == 3) {
2211 btc8723b2ant_ps_tdma(btcoexist,
2212 NORMAL_EXEC,
2213 true, 7);
2214 coex_dm->tdma_adj_type = 7;
2215 } else {
2216 btc8723b2ant_ps_tdma(btcoexist,
2217 NORMAL_EXEC,
2218 true, 7);
2219 coex_dm->tdma_adj_type = 7;
2220 }
2221 } else {
2222 if (max_interval == 1) {
2223 btc8723b2ant_ps_tdma(btcoexist,
2224 NORMAL_EXEC,
2225 true, 1);
2226 coex_dm->tdma_adj_type = 1;
2227 } else if (max_interval == 2) {
2228 btc8723b2ant_ps_tdma(btcoexist,
2229 NORMAL_EXEC,
2230 true, 2);
2231 coex_dm->tdma_adj_type = 2;
2232 } else if (max_interval == 3) {
2233 btc8723b2ant_ps_tdma(btcoexist,
2234 NORMAL_EXEC,
2235 true, 3);
2236 coex_dm->tdma_adj_type = 3;
2237 } else {
2238 btc8723b2ant_ps_tdma(btcoexist,
2239 NORMAL_EXEC,
2240 true, 3);
2241 coex_dm->tdma_adj_type = 3;
2242 }
2243 }
2244 }
2245
2246 up = 0;
2247 dn = 0;
2248 m = 1;
2249 n = 3;
2250 result = 0;
2251 wait_count = 0;
2252 } else {
2253 /*accquire the BT TRx retry count from BT_Info byte2*/
2254 retry_count = coex_sta->bt_retry_cnt;
2255 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2256 "[BTCoex], retry_count = %d\n", retry_count);
2257 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2258 "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
2259 up, dn, m, n, wait_count);
2260 result = 0;
2261 wait_count++;
2262 /* no retry in the last 2-second duration*/
2263 if (retry_count == 0) {
2264 up++;
2265 dn--;
2266
2267 if (dn <= 0)
2268 dn = 0;
2269
2270 if (up >= n) {
2271 wait_count = 0;
2272 n = 3;
2273 up = 0;
2274 dn = 0;
2275 result = 1;
2276 BTC_PRINT(BTC_MSG_ALGORITHM,
2277 ALGO_TRACE_FW_DETAIL,
2278 "[BTCoex], Increase wifi "
2279 "duration!!\n");
2280 } /* <=3 retry in the last 2-second duration*/
2281 } else if (retry_count <= 3) {
2282 up--;
2283 dn++;
2284
2285 if (up <= 0)
2286 up = 0;
2287
2288 if (dn == 2) {
2289 if (wait_count <= 2)
2290 m++;
2291 else
2292 m = 1;
2293
2294 if (m >= 20)
2295 m = 20;
2296
2297 n = 3 * m;
2298 up = 0;
2299 dn = 0;
2300 wait_count = 0;
2301 result = -1;
2302 BTC_PRINT(BTC_MSG_ALGORITHM,
2303 ALGO_TRACE_FW_DETAIL,
2304 "[BTCoex], Decrease wifi duration "
2305 "for retry_counter<3!!\n");
2306 }
2307 } else {
2308 if (wait_count == 1)
2309 m++;
2310 else
2311 m = 1;
2312
2313 if (m >= 20)
2314 m = 20;
2315
2316 n = 3 * m;
2317 up = 0;
2318 dn = 0;
2319 wait_count = 0;
2320 result = -1;
2321 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2322 "[BTCoex], Decrease wifi duration "
2323 "for retry_counter>3!!\n");
2324 }
2325
2326 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2327 "[BTCoex], max Interval = %d\n", max_interval);
2328 if (max_interval == 1)
2329 set_tdma_int1(btcoexist, tx_pause, result);
2330 else if (max_interval == 2)
2331 set_tdma_int2(btcoexist, tx_pause, result);
2332 else if (max_interval == 3)
2333 set_tdma_int3(btcoexist, tx_pause, result);
2334 }
2335
2336 /*if current PsTdma not match with the recorded one (when scan, dhcp..),
2337 *then we have to adjust it back to the previous recorded one.
2338 */
2339 if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
2340 bool scan = false, link = false, roam = false;
2341 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2342 "[BTCoex], PsTdma type dismatch!!!, "
2343 "curPsTdma=%d, recordPsTdma=%d\n",
2344 coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
2345
2346 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2347 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2348 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2349
2350 if (!scan && !link && !roam)
2351 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2352 coex_dm->tdma_adj_type);
2353 else
2354 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2355 "[BTCoex], roaming/link/scan is under"
2356 " progress, will adjust next time!!!\n");
2357 }
2358 }
2359
2360 /* SCO only or SCO+PAN(HS) */
btc8723b2ant_action_sco(struct btc_coexist * btcoexist)2361 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2362 {
2363 u8 wifi_rssi_state;
2364 u32 wifi_bw;
2365
2366 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2367 0, 2, 15, 0);
2368
2369 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2370
2371 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2372
2373 if (btc8723b_need_dec_pwr(btcoexist))
2374 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2375 else
2376 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2377
2378 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2379
2380 /*for SCO quality at 11b/g mode*/
2381 if (BTC_WIFI_BW_LEGACY == wifi_bw)
2382 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 2);
2383 else /*for SCO quality & wifi performance balance at 11n mode*/
2384 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 8);
2385
2386 /*for voice quality */
2387 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2388
2389 /* sw mechanism */
2390 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2391 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2392 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2393 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2394 false, false);
2395 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2396 true, 0x4);
2397 } else {
2398 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2399 false, false);
2400 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2401 true, 0x4);
2402 }
2403 } else {
2404 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2405 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2406 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2407 false, false);
2408 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2409 true, 0x4);
2410 } else {
2411 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2412 false, false);
2413 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2414 true, 0x4);
2415 }
2416 }
2417 }
2418
btc8723b2ant_action_hid(struct btc_coexist * btcoexist)2419 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2420 {
2421 u8 wifi_rssi_state, bt_rssi_state;
2422 u32 wifi_bw;
2423
2424 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2425 0, 2, 15, 0);
2426 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2427
2428 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2429
2430 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2431
2432 if (btc8723b_need_dec_pwr(btcoexist))
2433 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2434 else
2435 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2436
2437 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2438
2439 if (BTC_WIFI_BW_LEGACY == wifi_bw) /*/for HID at 11b/g mode*/
2440 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2441 else /*for HID quality & wifi performance balance at 11n mode*/
2442 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 9);
2443
2444 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2445 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2446 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2447 else
2448 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2449
2450 /* sw mechanism */
2451 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2452 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2453 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2454 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2455 false, false);
2456 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2457 false, 0x18);
2458 } else {
2459 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2460 false, false);
2461 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2462 false, 0x18);
2463 }
2464 } else {
2465 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2466 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2467 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2468 false, false);
2469 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2470 false, 0x18);
2471 } else {
2472 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2473 false, false);
2474 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2475 false, 0x18);
2476 }
2477 }
2478 }
2479
2480 /*A2DP only / PAN(EDR) only/ A2DP+PAN(HS)*/
btc8723b2ant_action_a2dp(struct btc_coexist * btcoexist)2481 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2482 {
2483 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2484 u32 wifi_bw;
2485 u8 ap_num = 0;
2486
2487 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2488 0, 2, 15, 0);
2489 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist,
2490 1, 2, 40, 0);
2491 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2492
2493 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
2494
2495 /* define the office environment */
2496 /* driver don't know AP num in Linux, so we will never enter this if */
2497 if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) {
2498 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2499 0x0);
2500 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2501 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2502 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
2503 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2504
2505 /* sw mechanism */
2506 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2507 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2508 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2509 false, false);
2510 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2511 true, 0x18);
2512 } else {
2513 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2514 false, false);
2515 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2516 true, 0x18);
2517 }
2518 return;
2519 }
2520
2521 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2522
2523 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2524
2525 if (btc8723b_need_dec_pwr(btcoexist))
2526 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2527 else
2528 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2529
2530 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2531
2532 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2533 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2534 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2535 false, 1);
2536 else
2537 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2538
2539 /* sw mechanism */
2540 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2541 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2542 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2543 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2544 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2545 false, false);
2546 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2547 false, 0x18);
2548 } else {
2549 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2550 false, false);
2551 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2552 false, 0x18);
2553 }
2554 } else {
2555 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2556 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2557 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2558 false, false);
2559 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2560 false, 0x18);
2561 } else {
2562 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2563 false, false);
2564 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2565 false, 0x18);
2566 }
2567 }
2568 }
2569
btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist * btcoexist)2570 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2571 {
2572 u8 wifi_rssi_state;
2573 u32 wifi_bw;
2574
2575 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2576 0, 2, 15, 0);
2577
2578 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2579
2580 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2581
2582 if (btc8723b_need_dec_pwr(btcoexist))
2583 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2584 else
2585 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2586
2587 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2588
2589 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2590
2591 /* sw mechanism */
2592 btcoexist->btc_get(btcoexist,
2593 BTC_GET_U4_WIFI_BW, &wifi_bw);
2594 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2595 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2596 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2597 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2598 false, false);
2599 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2600 false, 0x18);
2601 } else {
2602 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2603 false, false);
2604 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2605 false, 0x18);
2606 }
2607 } else {
2608 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2609 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2610 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2611 false, false);
2612 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2613 false, 0x18);
2614 } else {
2615 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2616 false, false);
2617 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2618 false, 0x18);
2619 }
2620 }
2621 }
2622
btc8723b2ant_action_pan_edr(struct btc_coexist * btcoexist)2623 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
2624 {
2625 u8 wifi_rssi_state, bt_rssi_state;
2626 u32 wifi_bw;
2627
2628 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2629 0, 2, 15, 0);
2630 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2631
2632 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2633
2634 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2635
2636 if (btc8723b_need_dec_pwr(btcoexist))
2637 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2638 else
2639 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2640
2641 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 10);
2642
2643 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2644 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2645 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2646 else
2647 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2648
2649 /* sw mechanism */
2650 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2651 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2652 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2653 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2654 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2655 false, false);
2656 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2657 false, 0x18);
2658 } else {
2659 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2660 false, false);
2661 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2662 false, 0x18);
2663 }
2664 } else {
2665 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2666 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2667 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2668 false, false);
2669 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2670 false, 0x18);
2671 } else {
2672 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2673 false, false);
2674 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2675 false, 0x18);
2676 }
2677 }
2678 }
2679
2680 /*PAN(HS) only*/
btc8723b2ant_action_pan_hs(struct btc_coexist * btcoexist)2681 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
2682 {
2683 u8 wifi_rssi_state;
2684 u32 wifi_bw;
2685
2686 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2687 0, 2, 15, 0);
2688
2689 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2690
2691 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2692
2693 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2694 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2695 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2696 else
2697 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2698
2699 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2700
2701 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2702
2703 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2704 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2705 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2706 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2707 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2708 false, false);
2709 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2710 false, 0x18);
2711 } else {
2712 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2713 false, false);
2714 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2715 false, 0x18);
2716 }
2717 } else {
2718 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2719 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2720 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2721 false, false);
2722 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2723 false, 0x18);
2724 } else {
2725 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2726 false, false);
2727 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2728 false, 0x18);
2729 }
2730 }
2731 }
2732
2733 /*PAN(EDR)+A2DP*/
btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist * btcoexist)2734 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
2735 {
2736 u8 wifi_rssi_state, bt_rssi_state;
2737 u32 wifi_bw;
2738
2739 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2740 0, 2, 15, 0);
2741 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2742
2743 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2744
2745 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2746
2747 if (btc8723b_need_dec_pwr(btcoexist))
2748 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2749 else
2750 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2751
2752 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2753
2754 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2755 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2756 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 12);
2757 if (BTC_WIFI_BW_HT40 == wifi_bw)
2758 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2759 true, 3);
2760 else
2761 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2762 false, 3);
2763 } else {
2764 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2765 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 3);
2766 }
2767
2768 /* sw mechanism */
2769 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2770 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2771 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2772 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2773 false, false);
2774 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2775 false, 0x18);
2776 } else {
2777 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2778 false, false);
2779 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2780 false, 0x18);
2781 }
2782 } else {
2783 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2784 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2785 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2786 false, false);
2787 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2788 false, 0x18);
2789 } else {
2790 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2791 false, false);
2792 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2793 false, 0x18);
2794 }
2795 }
2796 }
2797
btc8723b2ant_action_pan_edr_hid(struct btc_coexist * btcoexist)2798 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
2799 {
2800 u8 wifi_rssi_state, bt_rssi_state;
2801 u32 wifi_bw;
2802
2803 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2804 0, 2, 15, 0);
2805 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2806 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2807
2808 if (btc8723b_need_dec_pwr(btcoexist))
2809 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2810 else
2811 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2812
2813 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2814 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2815 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2816 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2817 3);
2818 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2819 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2820 0xfffff, 0x780);
2821 } else {
2822 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2823 6);
2824 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2825 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2826 0xfffff, 0x0);
2827 }
2828 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2829 } else {
2830 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2831 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2832 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2833 0x0);
2834 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2835 }
2836
2837 /* sw mechanism */
2838 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2839 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2840 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2841 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2842 false, false);
2843 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2844 false, 0x18);
2845 } else {
2846 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2847 false, false);
2848 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2849 false, 0x18);
2850 }
2851 } else {
2852 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2853 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2854 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2855 false, false);
2856 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2857 false, 0x18);
2858 } else {
2859 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2860 false, false);
2861 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2862 false, 0x18);
2863 }
2864 }
2865 }
2866
2867 /* HID+A2DP+PAN(EDR) */
btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist * btcoexist)2868 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
2869 {
2870 u8 wifi_rssi_state, bt_rssi_state;
2871 u32 wifi_bw;
2872
2873 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2874 0, 2, 15, 0);
2875 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2876
2877 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2878
2879 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2880
2881 if (btc8723b_need_dec_pwr(btcoexist))
2882 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2883 else
2884 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2885
2886 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2887
2888 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2889
2890 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2891 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2892 if (BTC_WIFI_BW_HT40 == wifi_bw)
2893 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2894 true, 2);
2895 else
2896 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2897 false, 3);
2898 } else {
2899 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
2900 }
2901
2902 /* sw mechanism */
2903 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2904 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2905 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2906 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2907 false, false);
2908 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2909 false, 0x18);
2910 } else {
2911 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2912 false, false);
2913 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2914 false, 0x18);
2915 }
2916 } else {
2917 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2918 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2919 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2920 false, false);
2921 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2922 false, 0x18);
2923 } else {
2924 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2925 false, false);
2926 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2927 false, 0x18);
2928 }
2929 }
2930 }
2931
btc8723b2ant_action_hid_a2dp(struct btc_coexist * btcoexist)2932 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
2933 {
2934 u8 wifi_rssi_state, bt_rssi_state;
2935 u32 wifi_bw;
2936
2937 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2938 0, 2, 15, 0);
2939 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2940
2941 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2942
2943 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2944
2945 if (btc8723b_need_dec_pwr(btcoexist))
2946 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2947 else
2948 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2949
2950 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2951
2952 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2953
2954 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2955 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2956 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2957 else
2958 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2959
2960 /* sw mechanism */
2961 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2962 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2963 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2964 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2965 false, false);
2966 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2967 false, 0x18);
2968 } else {
2969 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2970 false, false);
2971 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2972 false, 0x18);
2973 }
2974 } else {
2975 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2976 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2977 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2978 false, false);
2979 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2980 false, 0x18);
2981 } else {
2982 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2983 false, false);
2984 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2985 false, 0x18);
2986 }
2987 }
2988 }
2989
btc8723b2ant_run_coexist_mechanism(struct btc_coexist * btcoexist)2990 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
2991 {
2992 u8 algorithm = 0;
2993
2994 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2995 "[BTCoex], RunCoexistMechanism()===>\n");
2996
2997 if (btcoexist->manual_control) {
2998 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2999 "[BTCoex], RunCoexistMechanism(), "
3000 "return for Manual CTRL <===\n");
3001 return;
3002 }
3003
3004 if (coex_sta->under_ips) {
3005 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3006 "[BTCoex], wifi is under IPS !!!\n");
3007 return;
3008 }
3009
3010 algorithm = btc8723b2ant_action_algorithm(btcoexist);
3011 if (coex_sta->c2h_bt_inquiry_page &&
3012 (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
3013 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3014 "[BTCoex], BT is under inquiry/page scan !!\n");
3015 btc8723b2ant_action_bt_inquiry(btcoexist);
3016 return;
3017 } else {
3018 if (coex_dm->need_recover_0x948) {
3019 coex_dm->need_recover_0x948 = false;
3020 btcoexist->btc_write_2byte(btcoexist, 0x948,
3021 coex_dm->backup_0x948);
3022 }
3023 }
3024
3025 coex_dm->cur_algorithm = algorithm;
3026 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Algorithm = %d\n",
3027 coex_dm->cur_algorithm);
3028
3029 if (btc8723b2ant_is_common_action(btcoexist)) {
3030 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3031 "[BTCoex], Action 2-Ant common.\n");
3032 coex_dm->auto_tdma_adjust = false;
3033 } else {
3034 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3035 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3036 "[BTCoex], preAlgorithm=%d, "
3037 "curAlgorithm=%d\n", coex_dm->pre_algorithm,
3038 coex_dm->cur_algorithm);
3039 coex_dm->auto_tdma_adjust = false;
3040 }
3041 switch (coex_dm->cur_algorithm) {
3042 case BT_8723B_2ANT_COEX_ALGO_SCO:
3043 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3044 "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
3045 btc8723b2ant_action_sco(btcoexist);
3046 break;
3047 case BT_8723B_2ANT_COEX_ALGO_HID:
3048 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3049 "[BTCoex], Action 2-Ant, algorithm = HID.\n");
3050 btc8723b2ant_action_hid(btcoexist);
3051 break;
3052 case BT_8723B_2ANT_COEX_ALGO_A2DP:
3053 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3054 "[BTCoex], Action 2-Ant, "
3055 "algorithm = A2DP.\n");
3056 btc8723b2ant_action_a2dp(btcoexist);
3057 break;
3058 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
3059 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3060 "[BTCoex], Action 2-Ant, "
3061 "algorithm = A2DP+PAN(HS).\n");
3062 btc8723b2ant_action_a2dp_pan_hs(btcoexist);
3063 break;
3064 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
3065 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3066 "[BTCoex], Action 2-Ant, "
3067 "algorithm = PAN(EDR).\n");
3068 btc8723b2ant_action_pan_edr(btcoexist);
3069 break;
3070 case BT_8723B_2ANT_COEX_ALGO_PANHS:
3071 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3072 "[BTCoex], Action 2-Ant, "
3073 "algorithm = HS mode.\n");
3074 btc8723b2ant_action_pan_hs(btcoexist);
3075 break;
3076 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
3077 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3078 "[BTCoex], Action 2-Ant, "
3079 "algorithm = PAN+A2DP.\n");
3080 btc8723b2ant_action_pan_edr_a2dp(btcoexist);
3081 break;
3082 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
3083 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3084 "[BTCoex], Action 2-Ant, "
3085 "algorithm = PAN(EDR)+HID.\n");
3086 btc8723b2ant_action_pan_edr_hid(btcoexist);
3087 break;
3088 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3089 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3090 "[BTCoex], Action 2-Ant, "
3091 "algorithm = HID+A2DP+PAN.\n");
3092 btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
3093 break;
3094 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
3095 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3096 "[BTCoex], Action 2-Ant, "
3097 "algorithm = HID+A2DP.\n");
3098 btc8723b2ant_action_hid_a2dp(btcoexist);
3099 break;
3100 default:
3101 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3102 "[BTCoex], Action 2-Ant, "
3103 "algorithm = coexist All Off!!\n");
3104 btc8723b2ant_coex_alloff(btcoexist);
3105 break;
3106 }
3107 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3108 }
3109 }
3110
btc8723b2ant_wifioff_hwcfg(struct btc_coexist * btcoexist)3111 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist)
3112 {
3113 /* set wlan_act to low */
3114 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3115 /* Force GNT_BT to High */
3116 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3);
3117 /* BT select s0/s1 is controlled by BT */
3118 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
3119 }
3120
3121 /*********************************************************************
3122 * work around function start with wa_btc8723b2ant_
3123 *********************************************************************/
3124 /*********************************************************************
3125 * extern function start with EXbtc8723b2ant_
3126 *********************************************************************/
ex_btc8723b2ant_init_hwconfig(struct btc_coexist * btcoexist)3127 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
3128 {
3129 u8 u8tmp = 0;
3130
3131 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3132 "[BTCoex], 2Ant Init HW Config!!\n");
3133 coex_dm->bt_rf0x1e_backup =
3134 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3135
3136 /* 0x790[5:0] = 0x5 */
3137 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3138 u8tmp &= 0xc0;
3139 u8tmp |= 0x5;
3140 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3141
3142 /*Antenna config */
3143 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
3144 true, false);
3145 /* PTA parameter */
3146 btc8723b_coex_tbl_type(btcoexist, FORCE_EXEC, 0);
3147
3148 /* Enable counter statistics */
3149 /*0x76e[3] =1, WLAN_Act control by PTA*/
3150 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
3151 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3152 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3153 }
3154
ex_btc8723b2ant_init_coex_dm(struct btc_coexist * btcoexist)3155 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3156 {
3157 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3158 "[BTCoex], Coex Mechanism Init!!\n");
3159 btc8723b2ant_init_coex_dm(btcoexist);
3160 }
3161
ex_btc8723b2ant_display_coex_info(struct btc_coexist * btcoexist)3162 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
3163 {
3164 struct btc_board_info *board_info = &btcoexist->board_info;
3165 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3166 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3167 struct rtl_priv *rtlpriv = btcoexist->adapter;
3168 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3169 u32 u32tmp[4];
3170 bool roam = false, scan = false;
3171 bool link = false, wifi_under_5g = false;
3172 bool bt_hs_on = false, wifi_busy = false;
3173 s32 wifi_rssi = 0, bt_hs_rssi = 0;
3174 u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3175 u8 wifi_dot11_chnl, wifi_hs_chnl;
3176 u32 fw_ver = 0, bt_patch_ver = 0;
3177 u8 ap_num = 0;
3178
3179 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3180 "\r\n ============[BT Coexist info]============");
3181
3182 if (btcoexist->manual_control) {
3183 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3184 "\r\n ==========[Under Manual Control]============");
3185 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3186 "\r\n ==========================================");
3187 }
3188
3189 if (!board_info->bt_exist) {
3190 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3191 return;
3192 }
3193
3194 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3195 "Ant PG number/ Ant mechanism:",
3196 board_info->pg_ant_num, board_info->btdm_ant_num);
3197
3198 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
3199 "BT stack/ hci ext ver",
3200 ((stack_info->profile_notified) ? "Yes" : "No"),
3201 stack_info->hci_version);
3202
3203 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3204 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3205 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3206 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3207 "CoexVer/ FwVer/ PatchVer",
3208 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3209 fw_ver, bt_patch_ver, bt_patch_ver);
3210
3211 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3212 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3213 &wifi_dot11_chnl);
3214 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3215
3216 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
3217 "Dot11 channel / HsChnl(HsMode)",
3218 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3219
3220 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %02x %02x %02x ",
3221 "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info[0],
3222 coex_dm->wifi_chnl_info[1], coex_dm->wifi_chnl_info[2]);
3223
3224 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3225 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3226 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3227 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d",
3228 "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num);
3229
3230 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3231 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3232 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3233 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3234 "Wifi link/ roam/ scan", link, roam, scan);
3235
3236 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3237 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3238 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3239 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3240 &wifi_traffic_dir);
3241 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
3242 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3243 ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3244 (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3245 ((!wifi_busy) ? "idle" :
3246 ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3247 "uplink" : "downlink")));
3248
3249
3250 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d",
3251 "SCO/HID/PAN/A2DP",
3252 bt_link_info->sco_exist, bt_link_info->hid_exist,
3253 bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3254 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3255
3256 bt_info_ext = coex_sta->bt_info_ext;
3257 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3258 "BT Info A2DP rate",
3259 (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3260
3261 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3262 if (coex_sta->bt_info_c2h_cnt[i]) {
3263 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3264 "\r\n %-35s = %02x %02x %02x "
3265 "%02x %02x %02x %02x(%d)",
3266 glbt_info_src_8723b_2ant[i],
3267 coex_sta->bt_info_c2h[i][0],
3268 coex_sta->bt_info_c2h[i][1],
3269 coex_sta->bt_info_c2h[i][2],
3270 coex_sta->bt_info_c2h[i][3],
3271 coex_sta->bt_info_c2h[i][4],
3272 coex_sta->bt_info_c2h[i][5],
3273 coex_sta->bt_info_c2h[i][6],
3274 coex_sta->bt_info_c2h_cnt[i]);
3275 }
3276 }
3277
3278 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3279 "PS state, IPS/LPS",
3280 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3281 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3282 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3283
3284 /* Sw mechanism */
3285 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3286 "\r\n %-35s", "============[Sw mechanism]============");
3287 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3288 "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3289 coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3290 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3291 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3292 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3293 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3294
3295 /* Fw mechanism */
3296 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3297 "============[Fw mechanism]============");
3298
3299 ps_tdma_case = coex_dm->cur_ps_tdma;
3300 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3301 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)",
3302 "PS TDMA", coex_dm->ps_tdma_para[0],
3303 coex_dm->ps_tdma_para[1], coex_dm->ps_tdma_para[2],
3304 coex_dm->ps_tdma_para[3], coex_dm->ps_tdma_para[4],
3305 ps_tdma_case, coex_dm->auto_tdma_adjust);
3306
3307 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3308 "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr,
3309 coex_dm->cur_ignore_wlan_act);
3310
3311 /* Hw setting */
3312 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3313 "============[Hw setting]============");
3314
3315 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3316 "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3317
3318 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3319 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3320 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3321 "0x778/0x880[29:25]", u8tmp[0],
3322 (u32tmp[0]&0x3e000000) >> 25);
3323
3324 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3325 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3326 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3327 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3328 "0x948/ 0x67[5] / 0x765",
3329 u32tmp[0], ((u8tmp[0]&0x20) >> 5), u8tmp[1]);
3330
3331 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3332 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3333 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3334 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3335 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3336 u32tmp[0]&0x3, u32tmp[1]&0xff, u32tmp[2]&0x3);
3337
3338 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3339 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3340 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3341 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3342 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3343 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3344 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3345 ((u8tmp[0] & 0x8)>>3), u8tmp[1],
3346 ((u32tmp[0]&0x01800000)>>23), u8tmp[2]&0x1);
3347
3348 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3349 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3350 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3351 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3352
3353 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3354 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3355 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3356 "0xc50(dig)/0x49c(null-drop)", u32tmp[0]&0xff, u8tmp[0]);
3357
3358 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3359 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3360 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3361 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3362
3363 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3364 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3365
3366 fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3367 ((u32tmp[1]&0xffff0000) >> 16) +
3368 (u32tmp[1] & 0xffff) +
3369 (u32tmp[2] & 0xffff) +
3370 ((u32tmp[3]&0xffff0000) >> 16) +
3371 (u32tmp[3] & 0xffff);
3372 fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3373
3374 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3375 "OFDM-CCA/OFDM-FA/CCK-FA",
3376 u32tmp[0]&0xffff, fa_ofdm, fa_cck);
3377
3378 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3379 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3380 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3381 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3382 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3383 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3384 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3385 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3386
3387 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3388 "0x770(high-pri rx/tx)",
3389 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3390 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3391 "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
3392 coex_sta->low_priority_tx);
3393 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1)
3394 btc8723b2ant_monitor_bt_ctr(btcoexist);
3395 #endif
3396 btcoexist->btc_disp_dbg_msg(btcoexist,
3397 BTC_DBG_DISP_COEX_STATISTICS);
3398 }
3399
ex_btc8723b2ant_ips_notify(struct btc_coexist * btcoexist,u8 type)3400 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3401 {
3402 if (BTC_IPS_ENTER == type) {
3403 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3404 "[BTCoex], IPS ENTER notify\n");
3405 coex_sta->under_ips = true;
3406 btc8723b2ant_wifioff_hwcfg(btcoexist);
3407 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3408 btc8723b2ant_coex_alloff(btcoexist);
3409 } else if (BTC_IPS_LEAVE == type) {
3410 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3411 "[BTCoex], IPS LEAVE notify\n");
3412 coex_sta->under_ips = false;
3413 ex_btc8723b2ant_init_hwconfig(btcoexist);
3414 btc8723b2ant_init_coex_dm(btcoexist);
3415 btc8723b2ant_query_bt_info(btcoexist);
3416 }
3417 }
3418
ex_btc8723b2ant_lps_notify(struct btc_coexist * btcoexist,u8 type)3419 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3420 {
3421 if (BTC_LPS_ENABLE == type) {
3422 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3423 "[BTCoex], LPS ENABLE notify\n");
3424 coex_sta->under_lps = true;
3425 } else if (BTC_LPS_DISABLE == type) {
3426 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3427 "[BTCoex], LPS DISABLE notify\n");
3428 coex_sta->under_lps = false;
3429 }
3430 }
3431
ex_btc8723b2ant_scan_notify(struct btc_coexist * btcoexist,u8 type)3432 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3433 {
3434 if (BTC_SCAN_START == type)
3435 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3436 "[BTCoex], SCAN START notify\n");
3437 else if (BTC_SCAN_FINISH == type)
3438 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3439 "[BTCoex], SCAN FINISH notify\n");
3440 }
3441
ex_btc8723b2ant_connect_notify(struct btc_coexist * btcoexist,u8 type)3442 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3443 {
3444 if (BTC_ASSOCIATE_START == type)
3445 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3446 "[BTCoex], CONNECT START notify\n");
3447 else if (BTC_ASSOCIATE_FINISH == type)
3448 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3449 "[BTCoex], CONNECT FINISH notify\n");
3450 }
3451
ex_btc8723b2ant_media_status_notify(struct btc_coexist * btcoexist,u8 type)3452 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
3453 u8 type)
3454 {
3455 u8 h2c_parameter[3] = {0};
3456 u32 wifi_bw;
3457 u8 wifi_central_chnl;
3458
3459 if (BTC_MEDIA_CONNECT == type)
3460 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3461 "[BTCoex], MEDIA connect notify\n");
3462 else
3463 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3464 "[BTCoex], MEDIA disconnect notify\n");
3465
3466 /* only 2.4G we need to inform bt the chnl mask */
3467 btcoexist->btc_get(btcoexist,
3468 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
3469 if ((BTC_MEDIA_CONNECT == type) &&
3470 (wifi_central_chnl <= 14)) {
3471 h2c_parameter[0] = 0x1;
3472 h2c_parameter[1] = wifi_central_chnl;
3473 btcoexist->btc_get(btcoexist,
3474 BTC_GET_U4_WIFI_BW, &wifi_bw);
3475 if (BTC_WIFI_BW_HT40 == wifi_bw)
3476 h2c_parameter[2] = 0x30;
3477 else
3478 h2c_parameter[2] = 0x20;
3479 }
3480
3481 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3482 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3483 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3484
3485 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
3486 "[BTCoex], FW write 0x66=0x%x\n",
3487 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3488 h2c_parameter[2]);
3489
3490 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3491 }
3492
ex_btc8723b2ant_special_packet_notify(struct btc_coexist * btcoexist,u8 type)3493 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
3494 u8 type)
3495 {
3496 if (type == BTC_PACKET_DHCP)
3497 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3498 "[BTCoex], DHCP Packet notify\n");
3499 }
3500
ex_btc8723b2ant_bt_info_notify(struct btc_coexist * btcoexist,u8 * tmpbuf,u8 length)3501 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
3502 u8 *tmpbuf, u8 length)
3503 {
3504 u8 bt_info = 0;
3505 u8 i, rsp_source = 0;
3506 bool bt_busy = false, limited_dig = false;
3507 bool wifi_connected = false;
3508
3509 coex_sta->c2h_bt_info_req_sent = false;
3510
3511 rsp_source = tmpbuf[0]&0xf;
3512 if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
3513 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3514 coex_sta->bt_info_c2h_cnt[rsp_source]++;
3515
3516 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3517 "[BTCoex], Bt info[%d], length=%d, hex data=[",
3518 rsp_source, length);
3519 for (i = 0; i < length; i++) {
3520 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
3521 if (i == 1)
3522 bt_info = tmpbuf[i];
3523 if (i == length-1)
3524 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3525 "0x%02x]\n", tmpbuf[i]);
3526 else
3527 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3528 "0x%02x, ", tmpbuf[i]);
3529 }
3530
3531 if (btcoexist->manual_control) {
3532 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3533 "[BTCoex], BtInfoNotify(), "
3534 "return for Manual CTRL<===\n");
3535 return;
3536 }
3537
3538 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
3539 coex_sta->bt_retry_cnt = /* [3:0]*/
3540 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3541
3542 coex_sta->bt_rssi =
3543 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
3544
3545 coex_sta->bt_info_ext =
3546 coex_sta->bt_info_c2h[rsp_source][4];
3547
3548 /* Here we need to resend some wifi info to BT
3549 because bt is reset and loss of the info.
3550 */
3551 if ((coex_sta->bt_info_ext & BIT1)) {
3552 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3553 "[BTCoex], BT ext info bit1 check,"
3554 " send wifi BW&Chnl to BT!!\n");
3555 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3556 &wifi_connected);
3557 if (wifi_connected)
3558 ex_btc8723b2ant_media_status_notify(
3559 btcoexist,
3560 BTC_MEDIA_CONNECT);
3561 else
3562 ex_btc8723b2ant_media_status_notify(
3563 btcoexist,
3564 BTC_MEDIA_DISCONNECT);
3565 }
3566
3567 if ((coex_sta->bt_info_ext & BIT3)) {
3568 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3569 "[BTCoex], BT ext info bit3 check, "
3570 "set BT NOT to ignore Wlan active!!\n");
3571 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
3572 false);
3573 } else {
3574 /* BT already NOT ignore Wlan active, do nothing here.*/
3575 }
3576 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3577 if ((coex_sta->bt_info_ext & BIT4)) {
3578 /* BT auto report already enabled, do nothing*/
3579 } else {
3580 btc8723b2ant_bt_auto_report(btcoexist, FORCE_EXEC,
3581 true);
3582 }
3583 #endif
3584 }
3585
3586 /* check BIT2 first ==> check if bt is under inquiry or page scan*/
3587 if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
3588 coex_sta->c2h_bt_inquiry_page = true;
3589 else
3590 coex_sta->c2h_bt_inquiry_page = false;
3591
3592 /* set link exist status*/
3593 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3594 coex_sta->bt_link_exist = false;
3595 coex_sta->pan_exist = false;
3596 coex_sta->a2dp_exist = false;
3597 coex_sta->hid_exist = false;
3598 coex_sta->sco_exist = false;
3599 } else { /* connection exists */
3600 coex_sta->bt_link_exist = true;
3601 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
3602 coex_sta->pan_exist = true;
3603 else
3604 coex_sta->pan_exist = false;
3605 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
3606 coex_sta->a2dp_exist = true;
3607 else
3608 coex_sta->a2dp_exist = false;
3609 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
3610 coex_sta->hid_exist = true;
3611 else
3612 coex_sta->hid_exist = false;
3613 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
3614 coex_sta->sco_exist = true;
3615 else
3616 coex_sta->sco_exist = false;
3617 }
3618
3619 btc8723b2ant_update_bt_link_info(btcoexist);
3620
3621 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3622 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3623 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3624 "[BTCoex], BtInfoNotify(), "
3625 "BT Non-Connected idle!!!\n");
3626 /* connection exists but no busy */
3627 } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
3628 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
3629 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3630 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3631 } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
3632 (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
3633 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
3634 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3635 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3636 } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
3637 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
3638 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3639 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3640 } else {
3641 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
3642 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3643 "[BTCoex], BtInfoNotify(), "
3644 "BT Non-Defined state!!!\n");
3645 }
3646
3647 if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3648 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3649 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
3650 bt_busy = true;
3651 limited_dig = true;
3652 } else {
3653 bt_busy = false;
3654 limited_dig = false;
3655 }
3656
3657 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3658
3659 coex_dm->limited_dig = limited_dig;
3660 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
3661
3662 btc8723b2ant_run_coexist_mechanism(btcoexist);
3663 }
3664
ex_btc8723b2ant_halt_notify(struct btc_coexist * btcoexist)3665 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
3666 {
3667 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
3668
3669 btc8723b2ant_wifioff_hwcfg(btcoexist);
3670 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3671 ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3672 }
3673
ex_btc8723b2ant_periodical(struct btc_coexist * btcoexist)3674 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
3675 {
3676 struct btc_board_info *board_info = &btcoexist->board_info;
3677 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3678 static u8 dis_ver_info_cnt;
3679 u32 fw_ver = 0, bt_patch_ver = 0;
3680
3681 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3682 "[BTCoex], =========================="
3683 "Periodical===========================\n");
3684
3685 if (dis_ver_info_cnt <= 5) {
3686 dis_ver_info_cnt += 1;
3687 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3688 "[BTCoex], ****************************"
3689 "************************************\n");
3690 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3691 "[BTCoex], Ant PG Num/ Ant Mech/ "
3692 "Ant Pos = %d/ %d/ %d\n", board_info->pg_ant_num,
3693 board_info->btdm_ant_num, board_info->btdm_ant_pos);
3694 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3695 "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3696 ((stack_info->profile_notified) ? "Yes" : "No"),
3697 stack_info->hci_version);
3698 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3699 &bt_patch_ver);
3700 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3701 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3702 "[BTCoex], CoexVer/ fw_ver/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3703 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3704 fw_ver, bt_patch_ver, bt_patch_ver);
3705 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3706 "[BTCoex], *****************************"
3707 "***********************************\n");
3708 }
3709
3710 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3711 btc8723b2ant_query_bt_info(btcoexist);
3712 btc8723b2ant_monitor_bt_ctr(btcoexist);
3713 btc8723b2ant_monitor_bt_enable_disable(btcoexist);
3714 #else
3715 if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
3716 coex_dm->auto_tdma_adjust)
3717 btc8723b2ant_run_coexist_mechanism(btcoexist);
3718 #endif
3719 }
3720