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