1 /******************************************************************************
3 * Copyright(c) 2012 Realtek Corporation.
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.
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
14 * The full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
22 * Larry Finger <Larry.Finger@lwfinger.net>
24 *****************************************************************************/
25 /***************************************************************
28 * This file is for RTL8723B Co-exist mechanism
31 * 2012/11/15 Cosa first check in.
33 **************************************************************/
34 /**************************************************************
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;
46 static const char *const glbt_info_src_8723b_2ant[] = {
49 "BT Info[bt auto report]",
52 static u32 glcoex_ver_date_8723b_2ant = 20131113;
53 static u32 glcoex_ver_8723b_2ant = 0x3f;
55 /**************************************************************
56 * local function proto type if needed
57 **************************************************************/
58 /**************************************************************
59 * local function start with btc8723b2ant_
60 **************************************************************/
61 static u8 btc8723b2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
65 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
67 bt_rssi = coex_sta->bt_rssi;
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 "
79 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
80 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
81 "[BTCoex], BT Rssi state "
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 "
91 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
92 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
93 "[BTCoex], BT Rssi state "
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;
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");
113 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
114 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
115 "[BTCoex], BT Rssi state "
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 "
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 "
134 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
135 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
136 "[BTCoex], BT Rssi state "
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");
146 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
147 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
148 "[BTCoex], BT Rssi state "
154 coex_sta->pre_bt_rssi_state = bt_rssi_state;
156 return bt_rssi_state;
159 static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
160 u8 index, u8 level_num,
161 u8 rssi_thresh, u8 rssi_thresh1)
164 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
166 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
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 "
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 "
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 "
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 "
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];
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");
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 "
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 "
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 "
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 "
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");
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 "
268 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
270 return wifi_rssi_state;
273 static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
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;
282 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
283 reg_hp_tx = u32tmp & MASKLWORD;
284 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
286 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
287 reg_lp_tx = u32tmp & MASKLWORD;
288 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
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;
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);
303 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
306 static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist)
308 u8 h2c_parameter[1] = {0};
310 coex_sta->c2h_bt_info_req_sent = true;
312 h2c_parameter[0] |= BIT0; /* trigger */
314 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
315 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
318 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
321 static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
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;
329 btcoexist->btc_get(btcoexist, BTC_GET_BL_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,
336 if (wifi_connected) {
337 if (wifi_busy != pre_wifi_busy) {
338 pre_wifi_busy = wifi_busy;
342 if (under_4way != pre_under_4way) {
343 pre_under_4way = under_4way;
347 if (bt_hs_on != pre_bt_hs_on) {
348 pre_bt_hs_on = bt_hs_on;
356 static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist)
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;
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);
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;
371 /* work around for HS mode. */
373 bt_link_info->pan_exist = true;
374 bt_link_info->bt_link_exist = true;
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;
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;
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;
396 bt_link_info->sco_only = false;
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;
403 bt_link_info->a2dp_only = false;
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;
410 bt_link_info->pan_only = false;
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;
417 bt_link_info->hid_only = false;
420 static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
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;
427 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
429 if (!bt_link_info->bt_link_exist) {
430 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
431 "[BTCoex], No BT link exists!!!\n");
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++;
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;
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) {
460 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
461 "[BTCoex], PAN(HS) only\n");
463 BT_8723B_2ANT_COEX_ALGO_PANHS;
465 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
466 "[BTCoex], PAN(EDR) only\n");
468 BT_8723B_2ANT_COEX_ALGO_PANEDR;
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) {
484 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
485 "[BTCoex], SCO + PAN(HS)\n");
486 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
488 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
489 "[BTCoex], SCO + PAN(EDR)\n");
491 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
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) {
503 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
504 "[BTCoex], HID + PAN(HS)\n");
505 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
507 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
508 "[BTCoex], HID + PAN(EDR)\n");
510 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
512 } else if (bt_link_info->pan_exist &&
513 bt_link_info->a2dp_exist) {
515 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
516 "[BTCoex], A2DP + PAN(HS)\n");
518 BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
520 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
521 "[BTCoex],A2DP + PAN(EDR)\n");
523 BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
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"
534 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
535 } else if (bt_link_info->hid_exist &&
536 bt_link_info->pan_exist) {
538 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
539 "[BTCoex], SCO + HID + "
542 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
544 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
545 "[BTCoex], SCO + HID + "
548 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
550 } else if (bt_link_info->pan_exist &&
551 bt_link_info->a2dp_exist) {
553 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
554 "[BTCoex], SCO + A2DP + "
557 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
559 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
560 "[BTCoex], SCO + A2DP + "
561 "PAN(EDR) ==> HID\n");
563 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
567 if (bt_link_info->hid_exist &&
568 bt_link_info->pan_exist &&
569 bt_link_info->a2dp_exist) {
571 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
572 "[BTCoex], HID + A2DP + "
575 BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
577 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
578 "[BTCoex], HID + A2DP + "
581 BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
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) {
591 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
592 "[BTCoex], Error!!! SCO + HID"
593 " + A2DP + PAN(HS)\n");
595 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
596 "[BTCoex], SCO + HID + A2DP +"
597 " PAN(EDR)==>PAN(EDR)+HID\n");
599 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
607 static bool btc8723b_need_dec_pwr(struct btc_coexist *btcoexist)
610 bool bt_hs_on = false, wifi_connected = false;
614 if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on))
616 if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
619 if (!btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi))
622 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
624 if (wifi_connected) {
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");
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");
646 static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
649 u8 h2c_parameter[1] = {0};
651 /* There are several type of dacswing
652 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
654 h2c_parameter[0] = dac_swing_lvl;
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]);
661 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
664 static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
667 u8 h2c_parameter[1] = {0};
669 h2c_parameter[0] = 0;
672 h2c_parameter[0] |= BIT1;
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]);
678 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
681 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
682 bool force_exec, bool dec_bt_pwr)
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;
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);
694 if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr)
697 btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr);
699 coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr;
702 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
703 bool force_exec, u8 fw_dac_swing_lvl)
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;
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);
717 if (coex_dm->pre_fw_dac_swing_lvl ==
718 coex_dm->cur_fw_dac_swing_lvl)
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;
727 static void btc8723b2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
728 bool rx_rf_shrink_on)
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,
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,
744 coex_dm->bt_rf0x1e_backup);
749 static void btc8723b2ant_rf_shrink(struct btc_coexist *btcoexist,
750 bool force_exec, bool rx_rf_shrink_on)
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 ?
756 coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
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);
765 if (coex_dm->pre_rf_rx_lpf_shrink ==
766 coex_dm->cur_rf_rx_lpf_shrink)
769 btc8723b2ant_set_sw_rf_rx_lpf_corner(btcoexist,
770 coex_dm->cur_rf_rx_lpf_shrink);
772 coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink;
775 static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
778 u8 h2c_parameter[6] = {0};
780 h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty*/
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*/
791 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
792 "[BTCoex], set WiFi Low-Penalty Retry: %s",
793 (low_penalty_ra ? "ON!!" : "OFF!!"));
795 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
798 static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
799 bool force_exec, bool low_penalty_ra)
802 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
803 "[BTCoex], %s turn LowPenaltyRA = %s\n",
804 (force_exec ? "force to" : ""), (low_penalty_ra ?
806 coex_dm->cur_low_penalty_ra = low_penalty_ra;
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);
815 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
818 btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra);
820 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
823 static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
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);
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)
837 btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl);
839 btc8723b2ant_set_dac_swing_reg(btcoex, 0x18);
842 static void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
843 bool force_exec, bool dac_swing_on,
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;
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);
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))
866 btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on,
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;
873 static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
876 u8 rssi_adjust_val = 0;
878 /* BB AGC Gain Table */
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);
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);
902 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
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,
908 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
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,
915 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
918 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
920 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
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,
927 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
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,
934 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
937 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
939 /* set rssiAdjustVal for wifi module. */
942 btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON,
946 static void btc8723b2ant_agc_table(struct btc_coexist *btcoexist,
947 bool force_exec, bool agc_table_en)
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;
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);
960 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
963 btc8723b2ant_set_agc_table(btcoexist, agc_table_en);
965 coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en;
968 static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
969 u32 val0x6c0, u32 val0x6c4,
970 u32 val0x6c8, u8 val0x6cc)
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);
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);
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);
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);
989 static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
990 bool force_exec, u32 val0x6c0,
991 u32 val0x6c4, u32 val0x6c8,
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;
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);
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))
1024 btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
1025 val0x6c8, val0x6cc);
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;
1033 static void btc8723b_coex_tbl_type(struct btc_coexist *btcoexist,
1034 bool force_exec, u8 type)
1038 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
1039 0x55555555, 0xffff, 0x3);
1042 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
1043 0x5afa5afa, 0xffff, 0x3);
1046 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
1047 0x5a5a5a5a, 0xffff, 0x3);
1050 btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
1051 0xaaaaaaaa, 0xffff, 0x3);
1054 btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff,
1055 0xffffffff, 0xffff, 0x3);
1058 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
1059 0x5fff5fff, 0xffff, 0x3);
1062 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1063 0x5a5a5a5a, 0xffff, 0x3);
1066 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1067 0x5afa5afa, 0xffff, 0x3);
1070 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5aea5aea,
1071 0x5aea5aea, 0xffff, 0x3);
1074 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1075 0x5aea5aea, 0xffff, 0x3);
1078 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1079 0x5aff5aff, 0xffff, 0x3);
1082 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1083 0x5a5f5a5f, 0xffff, 0x3);
1086 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1087 0x5f5f5f5f, 0xffff, 0x3);
1094 static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
1097 u8 h2c_parameter[1] = {0};
1100 h2c_parameter[0] |= BIT0;/* function enable*/
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]);
1106 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1109 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1110 bool force_exec, bool enable)
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;
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);
1124 if (coex_dm->pre_ignore_wlan_act ==
1125 coex_dm->cur_ignore_wlan_act)
1128 btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1130 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1133 static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
1134 u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1136 u8 h2c_parameter[5];
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;
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;
1150 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
1151 "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
1153 h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1154 h2c_parameter[3] << 8 | h2c_parameter[4]);
1156 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
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)
1163 btc8723b2ant_rf_shrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf);
1164 btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
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)
1171 btc8723b2ant_agc_table(btcoexist, NORMAL_EXEC, agc_table_shift);
1172 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1176 static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
1177 u8 antpos_type, bool init_hwcfg,
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};
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);
1189 if ((fw_ver < 0xc0000) || pg_ext_switch)
1190 use_ext_switch = true;
1193 /* 0x4c[23] = 0, 0x4c[24] = 1 Antenna control by WL/BT */
1194 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1197 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
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);
1204 /* Force GNT_BT to low */
1205 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
1207 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1208 /* tell firmware "no antenna inverse" */
1209 h2c_parameter[0] = 0;
1210 h2c_parameter[1] = 1; /* ext switch type */
1211 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1213 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
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,
1220 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1224 /* ext switch setting */
1225 if (use_ext_switch) {
1226 /* fixed internal switch S1->WiFi, S0->BT */
1227 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1228 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1230 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1232 switch (antpos_type) {
1233 case BTC_ANT_WIFI_AT_MAIN:
1234 /* ext switch main at wifi */
1235 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
1238 case BTC_ANT_WIFI_AT_AUX:
1239 /* ext switch aux at wifi */
1240 btcoexist->btc_write_1byte_bitmask(btcoexist,
1244 } else { /* internal switch */
1245 /* fixed ext switch */
1246 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c, 0x3, 0x1);
1247 switch (antpos_type) {
1248 case BTC_ANT_WIFI_AT_MAIN:
1249 /* fixed internal switch S1->WiFi, S0->BT */
1250 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1252 case BTC_ANT_WIFI_AT_AUX:
1253 /* fixed internal switch S0->WiFi, S1->BT */
1254 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1260 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
1261 bool turn_on, u8 type)
1263 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
1264 "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1265 (force_exec ? "force to" : ""),
1266 (turn_on ? "ON" : "OFF"), type);
1267 coex_dm->cur_ps_tdma_on = turn_on;
1268 coex_dm->cur_ps_tdma = type;
1271 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1272 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1273 coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1274 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1275 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1276 coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1278 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1279 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1286 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1290 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1294 /* This call breaks BT when wireless is active -
1295 * comment it out for now until a better fix is found:
1296 * btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1301 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1305 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1309 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1313 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1317 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1321 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1325 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1329 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1333 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1337 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1341 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1345 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1349 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1353 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1357 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1361 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1365 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1369 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1373 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1378 /* disable PS tdma */
1381 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1385 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1389 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1395 /* update pre state */
1396 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1397 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1400 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1403 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1404 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1405 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1408 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1409 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1412 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1413 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1416 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1418 /* force to reset coex mechanism*/
1420 btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1421 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1422 btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, false);
1424 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1425 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1428 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1430 bool wifi_connected = false;
1431 bool low_pwr_disable = true;
1433 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1435 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1438 if (wifi_connected) {
1439 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
1440 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1442 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1443 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1445 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1446 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1448 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1449 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1451 coex_dm->need_recover_0x948 = true;
1452 coex_dm->backup_0x948 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1454 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_AUX,
1458 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1460 bool common = false, wifi_connected = false;
1461 bool wifi_busy = false;
1462 bool bt_hs_on = false, low_pwr_disable = false;
1464 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1465 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1467 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1469 if (!wifi_connected) {
1470 low_pwr_disable = false;
1471 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1474 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1475 "[BTCoex], Wifi non-connected idle!!\n");
1477 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1479 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1480 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1481 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1482 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1484 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false,
1486 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false,
1491 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1492 coex_dm->bt_status) {
1493 low_pwr_disable = false;
1494 btcoexist->btc_set(btcoexist,
1495 BTC_SET_ACT_DISABLE_LOW_POWER,
1498 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1499 "[BTCoex], Wifi connected + "
1500 "BT non connected-idle!!\n");
1502 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1504 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1505 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1506 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1508 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1511 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
1513 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1517 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1518 coex_dm->bt_status) {
1519 low_pwr_disable = true;
1520 btcoexist->btc_set(btcoexist,
1521 BTC_SET_ACT_DISABLE_LOW_POWER,
1526 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1527 "[BTCoex], Wifi connected + "
1528 "BT connected-idle!!\n");
1530 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1532 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1533 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1534 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1536 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1539 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
1541 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1546 low_pwr_disable = true;
1547 btcoexist->btc_set(btcoexist,
1548 BTC_SET_ACT_DISABLE_LOW_POWER,
1552 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1553 "[BTCoex], Wifi Connected-Busy + "
1560 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1561 "[BTCoex], Wifi Connected-Idle + "
1564 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1566 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC,
1568 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1570 btc8723b2ant_fw_dac_swing_lvl(btcoexist,
1573 if (btc8723b_need_dec_pwr(btcoexist))
1574 btc8723b2ant_dec_bt_pwr(btcoexist,
1578 btc8723b2ant_dec_bt_pwr(btcoexist,
1581 btc8723b2ant_sw_mechanism1(btcoexist, false,
1584 btc8723b2ant_sw_mechanism2(btcoexist, false,
1595 static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause,
1598 /* Set PS TDMA for max interval == 1 */
1600 BTC_PRINT(BTC_MSG_ALGORITHM,
1601 ALGO_TRACE_FW_DETAIL,
1602 "[BTCoex], TxPause = 1\n");
1604 if (coex_dm->cur_ps_tdma == 71) {
1605 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1607 coex_dm->tdma_adj_type = 5;
1608 } else if (coex_dm->cur_ps_tdma == 1) {
1609 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1611 coex_dm->tdma_adj_type = 5;
1612 } else if (coex_dm->cur_ps_tdma == 2) {
1613 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1615 coex_dm->tdma_adj_type = 6;
1616 } else if (coex_dm->cur_ps_tdma == 3) {
1617 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1619 coex_dm->tdma_adj_type = 7;
1620 } else if (coex_dm->cur_ps_tdma == 4) {
1621 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1623 coex_dm->tdma_adj_type = 8;
1626 if (coex_dm->cur_ps_tdma == 9) {
1627 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1629 coex_dm->tdma_adj_type = 13;
1630 } else if (coex_dm->cur_ps_tdma == 10) {
1631 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1633 coex_dm->tdma_adj_type = 14;
1634 } else if (coex_dm->cur_ps_tdma == 11) {
1635 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1637 coex_dm->tdma_adj_type = 15;
1638 } else if (coex_dm->cur_ps_tdma == 12) {
1639 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1641 coex_dm->tdma_adj_type = 16;
1645 if (coex_dm->cur_ps_tdma == 5) {
1646 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1648 coex_dm->tdma_adj_type = 6;
1649 } else if (coex_dm->cur_ps_tdma == 6) {
1650 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1652 coex_dm->tdma_adj_type = 7;
1653 } else if (coex_dm->cur_ps_tdma == 7) {
1654 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1656 coex_dm->tdma_adj_type = 8;
1657 } else if (coex_dm->cur_ps_tdma == 13) {
1658 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1660 coex_dm->tdma_adj_type = 14;
1661 } else if (coex_dm->cur_ps_tdma == 14) {
1662 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1664 coex_dm->tdma_adj_type = 15;
1665 } else if (coex_dm->cur_ps_tdma == 15) {
1666 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1668 coex_dm->tdma_adj_type = 16;
1670 } else if (result == 1) {
1671 if (coex_dm->cur_ps_tdma == 8) {
1672 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1674 coex_dm->tdma_adj_type = 7;
1675 } else if (coex_dm->cur_ps_tdma == 7) {
1676 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1678 coex_dm->tdma_adj_type = 6;
1679 } else if (coex_dm->cur_ps_tdma == 6) {
1680 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1682 coex_dm->tdma_adj_type = 5;
1683 } else if (coex_dm->cur_ps_tdma == 16) {
1684 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1686 coex_dm->tdma_adj_type = 15;
1687 } else if (coex_dm->cur_ps_tdma == 15) {
1688 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1690 coex_dm->tdma_adj_type = 14;
1691 } else if (coex_dm->cur_ps_tdma == 14) {
1692 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1694 coex_dm->tdma_adj_type = 13;
1698 BTC_PRINT(BTC_MSG_ALGORITHM,
1699 ALGO_TRACE_FW_DETAIL,
1700 "[BTCoex], TxPause = 0\n");
1701 if (coex_dm->cur_ps_tdma == 5) {
1702 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 71);
1703 coex_dm->tdma_adj_type = 71;
1704 } else if (coex_dm->cur_ps_tdma == 6) {
1705 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1706 coex_dm->tdma_adj_type = 2;
1707 } else if (coex_dm->cur_ps_tdma == 7) {
1708 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1709 coex_dm->tdma_adj_type = 3;
1710 } else if (coex_dm->cur_ps_tdma == 8) {
1711 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1712 coex_dm->tdma_adj_type = 4;
1715 if (coex_dm->cur_ps_tdma == 13) {
1716 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
1717 coex_dm->tdma_adj_type = 9;
1718 } else if (coex_dm->cur_ps_tdma == 14) {
1719 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1720 coex_dm->tdma_adj_type = 10;
1721 } else if (coex_dm->cur_ps_tdma == 15) {
1722 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1723 coex_dm->tdma_adj_type = 11;
1724 } else if (coex_dm->cur_ps_tdma == 16) {
1725 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1726 coex_dm->tdma_adj_type = 12;
1730 if (coex_dm->cur_ps_tdma == 71) {
1731 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1733 coex_dm->tdma_adj_type = 1;
1734 } else if (coex_dm->cur_ps_tdma == 1) {
1735 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1737 coex_dm->tdma_adj_type = 2;
1738 } else if (coex_dm->cur_ps_tdma == 2) {
1739 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1741 coex_dm->tdma_adj_type = 3;
1742 } else if (coex_dm->cur_ps_tdma == 3) {
1743 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1745 coex_dm->tdma_adj_type = 4;
1746 } else if (coex_dm->cur_ps_tdma == 9) {
1747 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1749 coex_dm->tdma_adj_type = 10;
1750 } else if (coex_dm->cur_ps_tdma == 10) {
1751 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1753 coex_dm->tdma_adj_type = 11;
1754 } else if (coex_dm->cur_ps_tdma == 11) {
1755 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1757 coex_dm->tdma_adj_type = 12;
1759 } else if (result == 1) {
1760 if (coex_dm->cur_ps_tdma == 4) {
1761 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1763 coex_dm->tdma_adj_type = 3;
1764 } else if (coex_dm->cur_ps_tdma == 3) {
1765 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1767 coex_dm->tdma_adj_type = 2;
1768 } else if (coex_dm->cur_ps_tdma == 2) {
1769 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1771 coex_dm->tdma_adj_type = 1;
1772 } else if (coex_dm->cur_ps_tdma == 1) {
1773 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1775 coex_dm->tdma_adj_type = 71;
1776 } else if (coex_dm->cur_ps_tdma == 12) {
1777 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1779 coex_dm->tdma_adj_type = 11;
1780 } else if (coex_dm->cur_ps_tdma == 11) {
1781 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1783 coex_dm->tdma_adj_type = 10;
1784 } else if (coex_dm->cur_ps_tdma == 10) {
1785 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1787 coex_dm->tdma_adj_type = 9;
1793 static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause,
1796 /* Set PS TDMA for max interval == 2 */
1798 BTC_PRINT(BTC_MSG_ALGORITHM,
1799 ALGO_TRACE_FW_DETAIL,
1800 "[BTCoex], TxPause = 1\n");
1801 if (coex_dm->cur_ps_tdma == 1) {
1802 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1803 coex_dm->tdma_adj_type = 6;
1804 } else if (coex_dm->cur_ps_tdma == 2) {
1805 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1806 coex_dm->tdma_adj_type = 6;
1807 } else if (coex_dm->cur_ps_tdma == 3) {
1808 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1809 coex_dm->tdma_adj_type = 7;
1810 } else if (coex_dm->cur_ps_tdma == 4) {
1811 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1812 coex_dm->tdma_adj_type = 8;
1814 if (coex_dm->cur_ps_tdma == 9) {
1815 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1816 coex_dm->tdma_adj_type = 14;
1817 } else if (coex_dm->cur_ps_tdma == 10) {
1818 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1819 coex_dm->tdma_adj_type = 14;
1820 } else if (coex_dm->cur_ps_tdma == 11) {
1821 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1822 coex_dm->tdma_adj_type = 15;
1823 } else if (coex_dm->cur_ps_tdma == 12) {
1824 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1825 coex_dm->tdma_adj_type = 16;
1828 if (coex_dm->cur_ps_tdma == 5) {
1829 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1831 coex_dm->tdma_adj_type = 6;
1832 } else if (coex_dm->cur_ps_tdma == 6) {
1833 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1835 coex_dm->tdma_adj_type = 7;
1836 } else if (coex_dm->cur_ps_tdma == 7) {
1837 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1839 coex_dm->tdma_adj_type = 8;
1840 } else if (coex_dm->cur_ps_tdma == 13) {
1841 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1843 coex_dm->tdma_adj_type = 14;
1844 } else if (coex_dm->cur_ps_tdma == 14) {
1845 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1847 coex_dm->tdma_adj_type = 15;
1848 } else if (coex_dm->cur_ps_tdma == 15) {
1849 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1851 coex_dm->tdma_adj_type = 16;
1853 } else if (result == 1) {
1854 if (coex_dm->cur_ps_tdma == 8) {
1855 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1857 coex_dm->tdma_adj_type = 7;
1858 } else if (coex_dm->cur_ps_tdma == 7) {
1859 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1861 coex_dm->tdma_adj_type = 6;
1862 } else if (coex_dm->cur_ps_tdma == 6) {
1863 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1865 coex_dm->tdma_adj_type = 6;
1866 } else if (coex_dm->cur_ps_tdma == 16) {
1867 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1869 coex_dm->tdma_adj_type = 15;
1870 } else if (coex_dm->cur_ps_tdma == 15) {
1871 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1873 coex_dm->tdma_adj_type = 14;
1874 } else if (coex_dm->cur_ps_tdma == 14) {
1875 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1877 coex_dm->tdma_adj_type = 14;
1881 BTC_PRINT(BTC_MSG_ALGORITHM,
1882 ALGO_TRACE_FW_DETAIL,
1883 "[BTCoex], TxPause = 0\n");
1884 if (coex_dm->cur_ps_tdma == 5) {
1885 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1886 coex_dm->tdma_adj_type = 2;
1887 } else if (coex_dm->cur_ps_tdma == 6) {
1888 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1889 coex_dm->tdma_adj_type = 2;
1890 } else if (coex_dm->cur_ps_tdma == 7) {
1891 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1892 coex_dm->tdma_adj_type = 3;
1893 } else if (coex_dm->cur_ps_tdma == 8) {
1894 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1895 coex_dm->tdma_adj_type = 4;
1897 if (coex_dm->cur_ps_tdma == 13) {
1898 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1899 coex_dm->tdma_adj_type = 10;
1900 } else if (coex_dm->cur_ps_tdma == 14) {
1901 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1902 coex_dm->tdma_adj_type = 10;
1903 } else if (coex_dm->cur_ps_tdma == 15) {
1904 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1905 coex_dm->tdma_adj_type = 11;
1906 } else if (coex_dm->cur_ps_tdma == 16) {
1907 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1908 coex_dm->tdma_adj_type = 12;
1911 if (coex_dm->cur_ps_tdma == 1) {
1912 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1914 coex_dm->tdma_adj_type = 2;
1915 } else if (coex_dm->cur_ps_tdma == 2) {
1916 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1918 coex_dm->tdma_adj_type = 3;
1919 } else if (coex_dm->cur_ps_tdma == 3) {
1920 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1922 coex_dm->tdma_adj_type = 4;
1923 } else if (coex_dm->cur_ps_tdma == 9) {
1924 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1926 coex_dm->tdma_adj_type = 10;
1927 } else if (coex_dm->cur_ps_tdma == 10) {
1928 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1930 coex_dm->tdma_adj_type = 11;
1931 } else if (coex_dm->cur_ps_tdma == 11) {
1932 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1934 coex_dm->tdma_adj_type = 12;
1936 } else if (result == 1) {
1937 if (coex_dm->cur_ps_tdma == 4) {
1938 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1940 coex_dm->tdma_adj_type = 3;
1941 } else if (coex_dm->cur_ps_tdma == 3) {
1942 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1944 coex_dm->tdma_adj_type = 2;
1945 } else if (coex_dm->cur_ps_tdma == 2) {
1946 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1948 coex_dm->tdma_adj_type = 2;
1949 } else if (coex_dm->cur_ps_tdma == 12) {
1950 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1952 coex_dm->tdma_adj_type = 11;
1953 } else if (coex_dm->cur_ps_tdma == 11) {
1954 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1956 coex_dm->tdma_adj_type = 10;
1957 } else if (coex_dm->cur_ps_tdma == 10) {
1958 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1960 coex_dm->tdma_adj_type = 10;
1966 static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause,
1969 /* Set PS TDMA for max interval == 3 */
1971 BTC_PRINT(BTC_MSG_ALGORITHM,
1972 ALGO_TRACE_FW_DETAIL,
1973 "[BTCoex], TxPause = 1\n");
1974 if (coex_dm->cur_ps_tdma == 1) {
1975 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1976 coex_dm->tdma_adj_type = 7;
1977 } else if (coex_dm->cur_ps_tdma == 2) {
1978 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1979 coex_dm->tdma_adj_type = 7;
1980 } else if (coex_dm->cur_ps_tdma == 3) {
1981 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1982 coex_dm->tdma_adj_type = 7;
1983 } else if (coex_dm->cur_ps_tdma == 4) {
1984 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1985 coex_dm->tdma_adj_type = 8;
1987 if (coex_dm->cur_ps_tdma == 9) {
1988 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1989 coex_dm->tdma_adj_type = 15;
1990 } else if (coex_dm->cur_ps_tdma == 10) {
1991 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1992 coex_dm->tdma_adj_type = 15;
1993 } else if (coex_dm->cur_ps_tdma == 11) {
1994 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1995 coex_dm->tdma_adj_type = 15;
1996 } else if (coex_dm->cur_ps_tdma == 12) {
1997 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1998 coex_dm->tdma_adj_type = 16;
2001 if (coex_dm->cur_ps_tdma == 5) {
2002 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2004 coex_dm->tdma_adj_type = 7;
2005 } else if (coex_dm->cur_ps_tdma == 6) {
2006 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2008 coex_dm->tdma_adj_type = 7;
2009 } else if (coex_dm->cur_ps_tdma == 7) {
2010 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2012 coex_dm->tdma_adj_type = 8;
2013 } else if (coex_dm->cur_ps_tdma == 13) {
2014 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2016 coex_dm->tdma_adj_type = 15;
2017 } else if (coex_dm->cur_ps_tdma == 14) {
2018 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2020 coex_dm->tdma_adj_type = 15;
2021 } else if (coex_dm->cur_ps_tdma == 15) {
2022 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2024 coex_dm->tdma_adj_type = 16;
2026 } else if (result == 1) {
2027 if (coex_dm->cur_ps_tdma == 8) {
2028 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2030 coex_dm->tdma_adj_type = 7;
2031 } else if (coex_dm->cur_ps_tdma == 7) {
2032 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2034 coex_dm->tdma_adj_type = 7;
2035 } else if (coex_dm->cur_ps_tdma == 6) {
2036 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2038 coex_dm->tdma_adj_type = 7;
2039 } else if (coex_dm->cur_ps_tdma == 16) {
2040 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2042 coex_dm->tdma_adj_type = 15;
2043 } else if (coex_dm->cur_ps_tdma == 15) {
2044 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2046 coex_dm->tdma_adj_type = 15;
2047 } else if (coex_dm->cur_ps_tdma == 14) {
2048 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2050 coex_dm->tdma_adj_type = 15;
2054 BTC_PRINT(BTC_MSG_ALGORITHM,
2055 ALGO_TRACE_FW_DETAIL,
2056 "[BTCoex], TxPause = 0\n");
2057 if (coex_dm->cur_ps_tdma == 5) {
2058 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2059 coex_dm->tdma_adj_type = 3;
2060 } else if (coex_dm->cur_ps_tdma == 6) {
2061 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2062 coex_dm->tdma_adj_type = 3;
2063 } else if (coex_dm->cur_ps_tdma == 7) {
2064 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2065 coex_dm->tdma_adj_type = 3;
2066 } else if (coex_dm->cur_ps_tdma == 8) {
2067 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
2068 coex_dm->tdma_adj_type = 4;
2070 if (coex_dm->cur_ps_tdma == 13) {
2071 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2072 coex_dm->tdma_adj_type = 11;
2073 } else if (coex_dm->cur_ps_tdma == 14) {
2074 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2075 coex_dm->tdma_adj_type = 11;
2076 } else if (coex_dm->cur_ps_tdma == 15) {
2077 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
2078 coex_dm->tdma_adj_type = 11;
2079 } else if (coex_dm->cur_ps_tdma == 16) {
2080 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
2081 coex_dm->tdma_adj_type = 12;
2084 if (coex_dm->cur_ps_tdma == 1) {
2085 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2087 coex_dm->tdma_adj_type = 3;
2088 } else if (coex_dm->cur_ps_tdma == 2) {
2089 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2091 coex_dm->tdma_adj_type = 3;
2092 } else if (coex_dm->cur_ps_tdma == 3) {
2093 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2095 coex_dm->tdma_adj_type = 4;
2096 } else if (coex_dm->cur_ps_tdma == 9) {
2097 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2099 coex_dm->tdma_adj_type = 11;
2100 } else if (coex_dm->cur_ps_tdma == 10) {
2101 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2103 coex_dm->tdma_adj_type = 11;
2104 } else if (coex_dm->cur_ps_tdma == 11) {
2105 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2107 coex_dm->tdma_adj_type = 12;
2109 } else if (result == 1) {
2110 if (coex_dm->cur_ps_tdma == 4) {
2111 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2113 coex_dm->tdma_adj_type = 3;
2114 } else if (coex_dm->cur_ps_tdma == 3) {
2115 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2117 coex_dm->tdma_adj_type = 3;
2118 } else if (coex_dm->cur_ps_tdma == 2) {
2119 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2121 coex_dm->tdma_adj_type = 3;
2122 } else if (coex_dm->cur_ps_tdma == 12) {
2123 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2125 coex_dm->tdma_adj_type = 11;
2126 } else if (coex_dm->cur_ps_tdma == 11) {
2127 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2129 coex_dm->tdma_adj_type = 11;
2130 } else if (coex_dm->cur_ps_tdma == 10) {
2131 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2133 coex_dm->tdma_adj_type = 11;
2139 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
2140 bool sco_hid, bool tx_pause,
2143 static s32 up, dn, m, n, wait_count;
2144 /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
2148 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
2149 "[BTCoex], TdmaDurationAdjust()\n");
2151 if (!coex_dm->auto_tdma_adjust) {
2152 coex_dm->auto_tdma_adjust = true;
2153 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2154 "[BTCoex], first run TdmaDurationAdjust()!!\n");
2157 if (max_interval == 1) {
2158 btc8723b2ant_ps_tdma(btcoexist,
2161 coex_dm->tdma_adj_type = 13;
2162 } else if (max_interval == 2) {
2163 btc8723b2ant_ps_tdma(btcoexist,
2166 coex_dm->tdma_adj_type = 14;
2167 } else if (max_interval == 3) {
2168 btc8723b2ant_ps_tdma(btcoexist,
2171 coex_dm->tdma_adj_type = 15;
2173 btc8723b2ant_ps_tdma(btcoexist,
2176 coex_dm->tdma_adj_type = 15;
2179 if (max_interval == 1) {
2180 btc8723b2ant_ps_tdma(btcoexist,
2183 coex_dm->tdma_adj_type = 9;
2184 } else if (max_interval == 2) {
2185 btc8723b2ant_ps_tdma(btcoexist,
2188 coex_dm->tdma_adj_type = 10;
2189 } else if (max_interval == 3) {
2190 btc8723b2ant_ps_tdma(btcoexist,
2193 coex_dm->tdma_adj_type = 11;
2195 btc8723b2ant_ps_tdma(btcoexist,
2198 coex_dm->tdma_adj_type = 11;
2203 if (max_interval == 1) {
2204 btc8723b2ant_ps_tdma(btcoexist,
2207 coex_dm->tdma_adj_type = 5;
2208 } else if (max_interval == 2) {
2209 btc8723b2ant_ps_tdma(btcoexist,
2212 coex_dm->tdma_adj_type = 6;
2213 } else if (max_interval == 3) {
2214 btc8723b2ant_ps_tdma(btcoexist,
2217 coex_dm->tdma_adj_type = 7;
2219 btc8723b2ant_ps_tdma(btcoexist,
2222 coex_dm->tdma_adj_type = 7;
2225 if (max_interval == 1) {
2226 btc8723b2ant_ps_tdma(btcoexist,
2229 coex_dm->tdma_adj_type = 1;
2230 } else if (max_interval == 2) {
2231 btc8723b2ant_ps_tdma(btcoexist,
2234 coex_dm->tdma_adj_type = 2;
2235 } else if (max_interval == 3) {
2236 btc8723b2ant_ps_tdma(btcoexist,
2239 coex_dm->tdma_adj_type = 3;
2241 btc8723b2ant_ps_tdma(btcoexist,
2244 coex_dm->tdma_adj_type = 3;
2256 /*accquire the BT TRx retry count from BT_Info byte2*/
2257 retry_count = coex_sta->bt_retry_cnt;
2258 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2259 "[BTCoex], retry_count = %d\n", retry_count);
2260 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2261 "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
2262 up, dn, m, n, wait_count);
2265 /* no retry in the last 2-second duration*/
2266 if (retry_count == 0) {
2279 BTC_PRINT(BTC_MSG_ALGORITHM,
2280 ALGO_TRACE_FW_DETAIL,
2281 "[BTCoex], Increase wifi "
2283 } /* <=3 retry in the last 2-second duration*/
2284 } else if (retry_count <= 3) {
2292 if (wait_count <= 2)
2305 BTC_PRINT(BTC_MSG_ALGORITHM,
2306 ALGO_TRACE_FW_DETAIL,
2307 "[BTCoex], Decrease wifi duration "
2308 "for retry_counter<3!!\n");
2311 if (wait_count == 1)
2324 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2325 "[BTCoex], Decrease wifi duration "
2326 "for retry_counter>3!!\n");
2329 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2330 "[BTCoex], max Interval = %d\n", max_interval);
2331 if (max_interval == 1)
2332 set_tdma_int1(btcoexist, tx_pause, result);
2333 else if (max_interval == 2)
2334 set_tdma_int2(btcoexist, tx_pause, result);
2335 else if (max_interval == 3)
2336 set_tdma_int3(btcoexist, tx_pause, result);
2339 /*if current PsTdma not match with the recorded one (when scan, dhcp..),
2340 *then we have to adjust it back to the previous recorded one.
2342 if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
2343 bool scan = false, link = false, roam = false;
2344 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2345 "[BTCoex], PsTdma type dismatch!!!, "
2346 "curPsTdma=%d, recordPsTdma=%d\n",
2347 coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
2349 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2350 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2351 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2353 if (!scan && !link && !roam)
2354 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2355 coex_dm->tdma_adj_type);
2357 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2358 "[BTCoex], roaming/link/scan is under"
2359 " progress, will adjust next time!!!\n");
2363 /* SCO only or SCO+PAN(HS) */
2364 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2369 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2372 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2374 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2376 if (btc8723b_need_dec_pwr(btcoexist))
2377 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2379 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2381 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2383 /*for SCO quality at 11b/g mode*/
2384 if (BTC_WIFI_BW_LEGACY == wifi_bw)
2385 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 2);
2386 else /*for SCO quality & wifi performance balance at 11n mode*/
2387 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 8);
2389 /*for voice quality */
2390 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2393 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2394 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2395 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2396 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2398 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2401 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2403 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2407 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2408 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2409 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2411 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2414 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2416 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2422 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2424 u8 wifi_rssi_state, bt_rssi_state;
2427 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2429 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2431 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2433 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2435 if (btc8723b_need_dec_pwr(btcoexist))
2436 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2438 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2440 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2442 if (BTC_WIFI_BW_LEGACY == wifi_bw) /*/for HID at 11b/g mode*/
2443 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2444 else /*for HID quality & wifi performance balance at 11n mode*/
2445 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 9);
2447 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2448 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2449 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2451 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2454 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2455 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2456 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2457 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2459 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2462 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2464 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2468 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2469 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2470 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2472 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2475 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2477 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2483 /*A2DP only / PAN(EDR) only/ A2DP+PAN(HS)*/
2484 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2486 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2490 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2492 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist,
2494 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2496 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
2498 /* define the office environment */
2499 /* driver don't know AP num in Linux, so we will never enter this if */
2500 if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) {
2501 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2503 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2504 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2505 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
2506 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2509 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2510 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2511 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2513 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2516 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2518 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2524 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2526 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2528 if (btc8723b_need_dec_pwr(btcoexist))
2529 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2531 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2533 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2535 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2536 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2537 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2540 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2543 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2544 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2545 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2546 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2547 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2549 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2552 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2554 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2558 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2559 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2560 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2562 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2565 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2567 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2573 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2578 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2581 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2583 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2585 if (btc8723b_need_dec_pwr(btcoexist))
2586 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2588 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2590 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2592 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2595 btcoexist->btc_get(btcoexist,
2596 BTC_GET_U4_WIFI_BW, &wifi_bw);
2597 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2598 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2599 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2600 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2602 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2605 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2607 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2611 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2612 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2613 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2615 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2618 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2620 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2626 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
2628 u8 wifi_rssi_state, bt_rssi_state;
2631 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2633 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2635 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2637 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2639 if (btc8723b_need_dec_pwr(btcoexist))
2640 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2642 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2644 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 10);
2646 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2647 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2648 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2650 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2653 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2654 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2655 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2656 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2657 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2659 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2662 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2664 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2668 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2669 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2670 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2672 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2675 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2677 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2684 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
2689 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2692 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2694 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2696 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2697 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2698 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2700 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2702 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2704 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2706 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2707 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2708 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2709 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2710 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2712 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2715 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2717 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2721 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2722 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2723 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2725 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2728 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2730 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2737 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
2739 u8 wifi_rssi_state, bt_rssi_state;
2742 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2744 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2746 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2748 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2750 if (btc8723b_need_dec_pwr(btcoexist))
2751 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2753 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2755 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2757 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2758 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2759 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 12);
2760 if (BTC_WIFI_BW_HT40 == wifi_bw)
2761 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2764 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2767 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2768 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 3);
2772 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2773 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2774 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2775 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2777 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2780 btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2782 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2786 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2787 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2788 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2790 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2793 btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2795 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2801 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
2803 u8 wifi_rssi_state, bt_rssi_state;
2806 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2808 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2809 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2811 if (btc8723b_need_dec_pwr(btcoexist))
2812 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2814 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2816 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2817 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2818 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2819 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2821 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2822 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2825 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2827 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2828 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2831 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2833 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2834 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2835 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2837 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2841 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2842 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2843 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2844 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2846 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2849 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2851 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2855 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2856 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2857 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2859 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2862 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2864 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2870 /* HID+A2DP+PAN(EDR) */
2871 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
2873 u8 wifi_rssi_state, bt_rssi_state;
2876 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2878 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2880 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2882 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2884 if (btc8723b_need_dec_pwr(btcoexist))
2885 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2887 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2889 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2891 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2893 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2894 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2895 if (BTC_WIFI_BW_HT40 == wifi_bw)
2896 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2899 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2902 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
2906 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2907 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2908 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2909 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2911 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2914 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2916 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2920 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2921 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2922 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2924 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2927 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2929 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2935 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
2937 u8 wifi_rssi_state, bt_rssi_state;
2940 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2942 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0);
2944 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2946 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2948 if (btc8723b_need_dec_pwr(btcoexist))
2949 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2951 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2953 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2955 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2957 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2958 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2959 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2961 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2964 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2965 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2966 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2967 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2969 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2972 btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2974 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2978 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2979 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2980 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2982 btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2985 btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2987 btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2993 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
2997 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2998 "[BTCoex], RunCoexistMechanism()===>\n");
3000 if (btcoexist->manual_control) {
3001 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3002 "[BTCoex], RunCoexistMechanism(), "
3003 "return for Manual CTRL <===\n");
3007 if (coex_sta->under_ips) {
3008 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3009 "[BTCoex], wifi is under IPS !!!\n");
3013 algorithm = btc8723b2ant_action_algorithm(btcoexist);
3014 if (coex_sta->c2h_bt_inquiry_page &&
3015 (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
3016 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3017 "[BTCoex], BT is under inquiry/page scan !!\n");
3018 btc8723b2ant_action_bt_inquiry(btcoexist);
3021 if (coex_dm->need_recover_0x948) {
3022 coex_dm->need_recover_0x948 = false;
3023 btcoexist->btc_write_2byte(btcoexist, 0x948,
3024 coex_dm->backup_0x948);
3028 coex_dm->cur_algorithm = algorithm;
3029 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Algorithm = %d\n",
3030 coex_dm->cur_algorithm);
3032 if (btc8723b2ant_is_common_action(btcoexist)) {
3033 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3034 "[BTCoex], Action 2-Ant common.\n");
3035 coex_dm->auto_tdma_adjust = false;
3037 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3038 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3039 "[BTCoex], preAlgorithm=%d, "
3040 "curAlgorithm=%d\n", coex_dm->pre_algorithm,
3041 coex_dm->cur_algorithm);
3042 coex_dm->auto_tdma_adjust = false;
3044 switch (coex_dm->cur_algorithm) {
3045 case BT_8723B_2ANT_COEX_ALGO_SCO:
3046 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3047 "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
3048 btc8723b2ant_action_sco(btcoexist);
3050 case BT_8723B_2ANT_COEX_ALGO_HID:
3051 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3052 "[BTCoex], Action 2-Ant, algorithm = HID.\n");
3053 btc8723b2ant_action_hid(btcoexist);
3055 case BT_8723B_2ANT_COEX_ALGO_A2DP:
3056 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3057 "[BTCoex], Action 2-Ant, "
3058 "algorithm = A2DP.\n");
3059 btc8723b2ant_action_a2dp(btcoexist);
3061 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
3062 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3063 "[BTCoex], Action 2-Ant, "
3064 "algorithm = A2DP+PAN(HS).\n");
3065 btc8723b2ant_action_a2dp_pan_hs(btcoexist);
3067 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
3068 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3069 "[BTCoex], Action 2-Ant, "
3070 "algorithm = PAN(EDR).\n");
3071 btc8723b2ant_action_pan_edr(btcoexist);
3073 case BT_8723B_2ANT_COEX_ALGO_PANHS:
3074 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3075 "[BTCoex], Action 2-Ant, "
3076 "algorithm = HS mode.\n");
3077 btc8723b2ant_action_pan_hs(btcoexist);
3079 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
3080 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3081 "[BTCoex], Action 2-Ant, "
3082 "algorithm = PAN+A2DP.\n");
3083 btc8723b2ant_action_pan_edr_a2dp(btcoexist);
3085 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
3086 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3087 "[BTCoex], Action 2-Ant, "
3088 "algorithm = PAN(EDR)+HID.\n");
3089 btc8723b2ant_action_pan_edr_hid(btcoexist);
3091 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3092 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3093 "[BTCoex], Action 2-Ant, "
3094 "algorithm = HID+A2DP+PAN.\n");
3095 btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
3097 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
3098 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3099 "[BTCoex], Action 2-Ant, "
3100 "algorithm = HID+A2DP.\n");
3101 btc8723b2ant_action_hid_a2dp(btcoexist);
3104 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3105 "[BTCoex], Action 2-Ant, "
3106 "algorithm = coexist All Off!!\n");
3107 btc8723b2ant_coex_alloff(btcoexist);
3110 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3114 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist)
3116 /* set wlan_act to low */
3117 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3118 /* Force GNT_BT to High */
3119 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3);
3120 /* BT select s0/s1 is controlled by BT */
3121 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
3124 /*********************************************************************
3125 * work around function start with wa_btc8723b2ant_
3126 *********************************************************************/
3127 /*********************************************************************
3128 * extern function start with EXbtc8723b2ant_
3129 *********************************************************************/
3130 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
3134 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3135 "[BTCoex], 2Ant Init HW Config!!\n");
3136 coex_dm->bt_rf0x1e_backup =
3137 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3139 /* 0x790[5:0] = 0x5 */
3140 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3143 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3146 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
3149 btc8723b_coex_tbl_type(btcoexist, FORCE_EXEC, 0);
3151 /* Enable counter statistics */
3152 /*0x76e[3] =1, WLAN_Act control by PTA*/
3153 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
3154 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3155 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3158 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3160 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3161 "[BTCoex], Coex Mechanism Init!!\n");
3162 btc8723b2ant_init_coex_dm(btcoexist);
3165 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
3167 struct btc_board_info *board_info = &btcoexist->board_info;
3168 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3169 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3170 struct rtl_priv *rtlpriv = btcoexist->adapter;
3171 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3173 bool roam = false, scan = false;
3174 bool link = false, wifi_under_5g = false;
3175 bool bt_hs_on = false, wifi_busy = false;
3176 s32 wifi_rssi = 0, bt_hs_rssi = 0;
3177 u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3178 u8 wifi_dot11_chnl, wifi_hs_chnl;
3179 u32 fw_ver = 0, bt_patch_ver = 0;
3182 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3183 "\r\n ============[BT Coexist info]============");
3185 if (btcoexist->manual_control) {
3186 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3187 "\r\n ==========[Under Manual Control]============");
3188 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3189 "\r\n ==========================================");
3192 if (!board_info->bt_exist) {
3193 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3197 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3198 "Ant PG number/ Ant mechanism:",
3199 board_info->pg_ant_num, board_info->btdm_ant_num);
3201 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
3202 "BT stack/ hci ext ver",
3203 ((stack_info->profile_notified) ? "Yes" : "No"),
3204 stack_info->hci_version);
3206 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3207 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3208 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3209 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3210 "CoexVer/ FwVer/ PatchVer",
3211 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3212 fw_ver, bt_patch_ver, bt_patch_ver);
3214 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3215 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3217 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3219 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
3220 "Dot11 channel / HsChnl(HsMode)",
3221 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3223 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %02x %02x %02x ",
3224 "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info[0],
3225 coex_dm->wifi_chnl_info[1], coex_dm->wifi_chnl_info[2]);
3227 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3228 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3229 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3230 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d",
3231 "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num);
3233 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3234 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3235 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3236 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3237 "Wifi link/ roam/ scan", link, roam, scan);
3239 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3240 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3241 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3242 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3244 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
3245 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3246 ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3247 (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3248 ((!wifi_busy) ? "idle" :
3249 ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3250 "uplink" : "downlink")));
3253 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d",
3255 bt_link_info->sco_exist, bt_link_info->hid_exist,
3256 bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3257 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3259 bt_info_ext = coex_sta->bt_info_ext;
3260 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3261 "BT Info A2DP rate",
3262 (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3264 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3265 if (coex_sta->bt_info_c2h_cnt[i]) {
3266 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3267 "\r\n %-35s = %02x %02x %02x "
3268 "%02x %02x %02x %02x(%d)",
3269 glbt_info_src_8723b_2ant[i],
3270 coex_sta->bt_info_c2h[i][0],
3271 coex_sta->bt_info_c2h[i][1],
3272 coex_sta->bt_info_c2h[i][2],
3273 coex_sta->bt_info_c2h[i][3],
3274 coex_sta->bt_info_c2h[i][4],
3275 coex_sta->bt_info_c2h[i][5],
3276 coex_sta->bt_info_c2h[i][6],
3277 coex_sta->bt_info_c2h_cnt[i]);
3281 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3282 "PS state, IPS/LPS",
3283 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3284 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3285 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3288 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3289 "\r\n %-35s", "============[Sw mechanism]============");
3290 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3291 "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3292 coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3293 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3294 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3295 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3296 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3299 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3300 "============[Fw mechanism]============");
3302 ps_tdma_case = coex_dm->cur_ps_tdma;
3303 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3304 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)",
3305 "PS TDMA", coex_dm->ps_tdma_para[0],
3306 coex_dm->ps_tdma_para[1], coex_dm->ps_tdma_para[2],
3307 coex_dm->ps_tdma_para[3], coex_dm->ps_tdma_para[4],
3308 ps_tdma_case, coex_dm->auto_tdma_adjust);
3310 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3311 "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr,
3312 coex_dm->cur_ignore_wlan_act);
3315 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3316 "============[Hw setting]============");
3318 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3319 "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3321 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3322 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3323 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3324 "0x778/0x880[29:25]", u8tmp[0],
3325 (u32tmp[0]&0x3e000000) >> 25);
3327 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3328 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3329 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3330 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3331 "0x948/ 0x67[5] / 0x765",
3332 u32tmp[0], ((u8tmp[0]&0x20) >> 5), u8tmp[1]);
3334 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3335 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3336 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3337 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3338 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3339 u32tmp[0]&0x3, u32tmp[1]&0xff, u32tmp[2]&0x3);
3341 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3342 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3343 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3344 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3345 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3346 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3347 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3348 ((u8tmp[0] & 0x8)>>3), u8tmp[1],
3349 ((u32tmp[0]&0x01800000)>>23), u8tmp[2]&0x1);
3351 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3352 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3353 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3354 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3356 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3357 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3358 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3359 "0xc50(dig)/0x49c(null-drop)", u32tmp[0]&0xff, u8tmp[0]);
3361 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3362 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3363 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3364 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3366 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3367 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3369 fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3370 ((u32tmp[1]&0xffff0000) >> 16) +
3371 (u32tmp[1] & 0xffff) +
3372 (u32tmp[2] & 0xffff) +
3373 ((u32tmp[3]&0xffff0000) >> 16) +
3374 (u32tmp[3] & 0xffff);
3375 fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3377 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3378 "OFDM-CCA/OFDM-FA/CCK-FA",
3379 u32tmp[0]&0xffff, fa_ofdm, fa_cck);
3381 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3382 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3383 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3384 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3385 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3386 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3387 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3388 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3390 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3391 "0x770(high-pri rx/tx)",
3392 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3393 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3394 "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
3395 coex_sta->low_priority_tx);
3396 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1)
3397 btc8723b2ant_monitor_bt_ctr(btcoexist);
3399 btcoexist->btc_disp_dbg_msg(btcoexist,
3400 BTC_DBG_DISP_COEX_STATISTICS);
3403 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3405 if (BTC_IPS_ENTER == type) {
3406 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3407 "[BTCoex], IPS ENTER notify\n");
3408 coex_sta->under_ips = true;
3409 btc8723b2ant_wifioff_hwcfg(btcoexist);
3410 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3411 btc8723b2ant_coex_alloff(btcoexist);
3412 } else if (BTC_IPS_LEAVE == type) {
3413 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3414 "[BTCoex], IPS LEAVE notify\n");
3415 coex_sta->under_ips = false;
3416 ex_btc8723b2ant_init_hwconfig(btcoexist);
3417 btc8723b2ant_init_coex_dm(btcoexist);
3418 btc8723b2ant_query_bt_info(btcoexist);
3422 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3424 if (BTC_LPS_ENABLE == type) {
3425 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3426 "[BTCoex], LPS ENABLE notify\n");
3427 coex_sta->under_lps = true;
3428 } else if (BTC_LPS_DISABLE == type) {
3429 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3430 "[BTCoex], LPS DISABLE notify\n");
3431 coex_sta->under_lps = false;
3435 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3437 if (BTC_SCAN_START == type)
3438 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3439 "[BTCoex], SCAN START notify\n");
3440 else if (BTC_SCAN_FINISH == type)
3441 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3442 "[BTCoex], SCAN FINISH notify\n");
3445 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3447 if (BTC_ASSOCIATE_START == type)
3448 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3449 "[BTCoex], CONNECT START notify\n");
3450 else if (BTC_ASSOCIATE_FINISH == type)
3451 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3452 "[BTCoex], CONNECT FINISH notify\n");
3455 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
3458 u8 h2c_parameter[3] = {0};
3460 u8 wifi_central_chnl;
3462 if (BTC_MEDIA_CONNECT == type)
3463 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3464 "[BTCoex], MEDIA connect notify\n");
3466 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3467 "[BTCoex], MEDIA disconnect notify\n");
3469 /* only 2.4G we need to inform bt the chnl mask */
3470 btcoexist->btc_get(btcoexist,
3471 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
3472 if ((BTC_MEDIA_CONNECT == type) &&
3473 (wifi_central_chnl <= 14)) {
3474 h2c_parameter[0] = 0x1;
3475 h2c_parameter[1] = wifi_central_chnl;
3476 btcoexist->btc_get(btcoexist,
3477 BTC_GET_U4_WIFI_BW, &wifi_bw);
3478 if (BTC_WIFI_BW_HT40 == wifi_bw)
3479 h2c_parameter[2] = 0x30;
3481 h2c_parameter[2] = 0x20;
3484 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3485 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3486 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3488 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
3489 "[BTCoex], FW write 0x66=0x%x\n",
3490 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3493 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3496 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
3499 if (type == BTC_PACKET_DHCP)
3500 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3501 "[BTCoex], DHCP Packet notify\n");
3504 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
3505 u8 *tmpbuf, u8 length)
3508 u8 i, rsp_source = 0;
3509 bool bt_busy = false, limited_dig = false;
3510 bool wifi_connected = false;
3512 coex_sta->c2h_bt_info_req_sent = false;
3514 rsp_source = tmpbuf[0]&0xf;
3515 if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
3516 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3517 coex_sta->bt_info_c2h_cnt[rsp_source]++;
3519 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3520 "[BTCoex], Bt info[%d], length=%d, hex data=[",
3521 rsp_source, length);
3522 for (i = 0; i < length; i++) {
3523 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
3525 bt_info = tmpbuf[i];
3527 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3528 "0x%02x]\n", tmpbuf[i]);
3530 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3531 "0x%02x, ", tmpbuf[i]);
3534 if (btcoexist->manual_control) {
3535 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3536 "[BTCoex], BtInfoNotify(), "
3537 "return for Manual CTRL<===\n");
3541 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
3542 coex_sta->bt_retry_cnt = /* [3:0]*/
3543 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3546 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
3548 coex_sta->bt_info_ext =
3549 coex_sta->bt_info_c2h[rsp_source][4];
3551 /* Here we need to resend some wifi info to BT
3552 because bt is reset and loss of the info.
3554 if ((coex_sta->bt_info_ext & BIT1)) {
3555 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3556 "[BTCoex], BT ext info bit1 check,"
3557 " send wifi BW&Chnl to BT!!\n");
3558 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3561 ex_btc8723b2ant_media_status_notify(
3565 ex_btc8723b2ant_media_status_notify(
3567 BTC_MEDIA_DISCONNECT);
3570 if ((coex_sta->bt_info_ext & BIT3)) {
3571 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3572 "[BTCoex], BT ext info bit3 check, "
3573 "set BT NOT to ignore Wlan active!!\n");
3574 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
3577 /* BT already NOT ignore Wlan active, do nothing here.*/
3579 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3580 if ((coex_sta->bt_info_ext & BIT4)) {
3581 /* BT auto report already enabled, do nothing*/
3583 btc8723b2ant_bt_auto_report(btcoexist, FORCE_EXEC,
3589 /* check BIT2 first ==> check if bt is under inquiry or page scan*/
3590 if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
3591 coex_sta->c2h_bt_inquiry_page = true;
3593 coex_sta->c2h_bt_inquiry_page = false;
3595 /* set link exist status*/
3596 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3597 coex_sta->bt_link_exist = false;
3598 coex_sta->pan_exist = false;
3599 coex_sta->a2dp_exist = false;
3600 coex_sta->hid_exist = false;
3601 coex_sta->sco_exist = false;
3602 } else { /* connection exists */
3603 coex_sta->bt_link_exist = true;
3604 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
3605 coex_sta->pan_exist = true;
3607 coex_sta->pan_exist = false;
3608 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
3609 coex_sta->a2dp_exist = true;
3611 coex_sta->a2dp_exist = false;
3612 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
3613 coex_sta->hid_exist = true;
3615 coex_sta->hid_exist = false;
3616 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
3617 coex_sta->sco_exist = true;
3619 coex_sta->sco_exist = false;
3622 btc8723b2ant_update_bt_link_info(btcoexist);
3624 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3625 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3626 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3627 "[BTCoex], BtInfoNotify(), "
3628 "BT Non-Connected idle!!!\n");
3629 /* connection exists but no busy */
3630 } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
3631 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
3632 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3633 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3634 } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
3635 (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
3636 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
3637 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3638 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3639 } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
3640 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
3641 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3642 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3644 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
3645 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3646 "[BTCoex], BtInfoNotify(), "
3647 "BT Non-Defined state!!!\n");
3650 if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3651 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3652 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
3657 limited_dig = false;
3660 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3662 coex_dm->limited_dig = limited_dig;
3663 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
3665 btc8723b2ant_run_coexist_mechanism(btcoexist);
3668 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
3670 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
3672 btc8723b2ant_wifioff_hwcfg(btcoexist);
3673 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3674 ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3677 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
3679 struct btc_board_info *board_info = &btcoexist->board_info;
3680 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3681 static u8 dis_ver_info_cnt;
3682 u32 fw_ver = 0, bt_patch_ver = 0;
3684 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3685 "[BTCoex], =========================="
3686 "Periodical===========================\n");
3688 if (dis_ver_info_cnt <= 5) {
3689 dis_ver_info_cnt += 1;
3690 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3691 "[BTCoex], ****************************"
3692 "************************************\n");
3693 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3694 "[BTCoex], Ant PG Num/ Ant Mech/ "
3695 "Ant Pos = %d/ %d/ %d\n", board_info->pg_ant_num,
3696 board_info->btdm_ant_num, board_info->btdm_ant_pos);
3697 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3698 "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3699 ((stack_info->profile_notified) ? "Yes" : "No"),
3700 stack_info->hci_version);
3701 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3703 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3704 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3705 "[BTCoex], CoexVer/ fw_ver/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3706 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3707 fw_ver, bt_patch_ver, bt_patch_ver);
3708 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3709 "[BTCoex], *****************************"
3710 "***********************************\n");
3713 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3714 btc8723b2ant_query_bt_info(btcoexist);
3715 btc8723b2ant_monitor_bt_ctr(btcoexist);
3716 btc8723b2ant_monitor_bt_enable_disable(btcoexist);
3718 if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
3719 coex_dm->auto_tdma_adjust)
3720 btc8723b2ant_run_coexist_mechanism(btcoexist);