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(struct btc_coexist *btcoexist,
62 u8 level_num, u8 rssi_thresh,
65 struct rtl_priv *rtlpriv = btcoexist->adapter;
67 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
69 bt_rssi = coex_sta->bt_rssi;
72 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
73 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
74 if (bt_rssi >= rssi_thresh +
75 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
76 bt_rssi_state = BTC_RSSI_STATE_HIGH;
77 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
78 "[BTCoex], BT Rssi state switch to High\n");
80 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
81 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
82 "[BTCoex], BT Rssi state stay at Low\n");
85 if (bt_rssi < rssi_thresh) {
86 bt_rssi_state = BTC_RSSI_STATE_LOW;
87 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
88 "[BTCoex], BT Rssi state switch to Low\n");
90 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
91 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
92 "[BTCoex], BT Rssi state stay at High\n");
95 } else if (level_num == 3) {
96 if (rssi_thresh > rssi_thresh1) {
97 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
98 "[BTCoex], BT Rssi thresh error!!\n");
99 return coex_sta->pre_bt_rssi_state;
102 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
103 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
104 if (bt_rssi >= rssi_thresh +
105 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
106 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
107 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
108 "[BTCoex], BT Rssi state switch to Medium\n");
110 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
111 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
112 "[BTCoex], BT Rssi state stay at Low\n");
114 } else if ((coex_sta->pre_bt_rssi_state ==
115 BTC_RSSI_STATE_MEDIUM) ||
116 (coex_sta->pre_bt_rssi_state ==
117 BTC_RSSI_STATE_STAY_MEDIUM)) {
118 if (bt_rssi >= rssi_thresh1 +
119 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
120 bt_rssi_state = BTC_RSSI_STATE_HIGH;
121 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
122 "[BTCoex], BT Rssi state switch to High\n");
123 } else if (bt_rssi < rssi_thresh) {
124 bt_rssi_state = BTC_RSSI_STATE_LOW;
125 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
126 "[BTCoex], BT Rssi state switch to Low\n");
128 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
129 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
130 "[BTCoex], BT Rssi state stay at Medium\n");
133 if (bt_rssi < rssi_thresh1) {
134 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
135 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
136 "[BTCoex], BT Rssi state switch to Medium\n");
138 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
139 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
140 "[BTCoex], BT Rssi state stay at High\n");
145 coex_sta->pre_bt_rssi_state = bt_rssi_state;
147 return bt_rssi_state;
150 static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
151 u8 index, u8 level_num,
152 u8 rssi_thresh, u8 rssi_thresh1)
154 struct rtl_priv *rtlpriv = btcoexist->adapter;
156 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
158 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
160 if (level_num == 2) {
161 if ((coex_sta->pre_wifi_rssi_state[index] ==
162 BTC_RSSI_STATE_LOW) ||
163 (coex_sta->pre_wifi_rssi_state[index] ==
164 BTC_RSSI_STATE_STAY_LOW)) {
165 if (wifi_rssi >= rssi_thresh +
166 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
167 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
168 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
169 "[BTCoex], wifi RSSI state switch to High\n");
171 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
172 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
173 "[BTCoex], wifi RSSI state stay at Low\n");
176 if (wifi_rssi < rssi_thresh) {
177 wifi_rssi_state = BTC_RSSI_STATE_LOW;
178 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
179 "[BTCoex], wifi RSSI state switch to Low\n");
181 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
182 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
183 "[BTCoex], wifi RSSI state stay at High\n");
186 } else if (level_num == 3) {
187 if (rssi_thresh > rssi_thresh1) {
188 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
189 "[BTCoex], wifi RSSI thresh error!!\n");
190 return coex_sta->pre_wifi_rssi_state[index];
193 if ((coex_sta->pre_wifi_rssi_state[index] ==
194 BTC_RSSI_STATE_LOW) ||
195 (coex_sta->pre_wifi_rssi_state[index] ==
196 BTC_RSSI_STATE_STAY_LOW)) {
197 if (wifi_rssi >= rssi_thresh +
198 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
199 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
200 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
201 "[BTCoex], wifi RSSI state switch to Medium\n");
203 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
204 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
205 "[BTCoex], wifi RSSI state stay at Low\n");
207 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
208 BTC_RSSI_STATE_MEDIUM) ||
209 (coex_sta->pre_wifi_rssi_state[index] ==
210 BTC_RSSI_STATE_STAY_MEDIUM)) {
211 if (wifi_rssi >= rssi_thresh1 +
212 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
213 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
214 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
215 "[BTCoex], wifi RSSI state switch to High\n");
216 } else if (wifi_rssi < rssi_thresh) {
217 wifi_rssi_state = BTC_RSSI_STATE_LOW;
218 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
219 "[BTCoex], wifi RSSI state switch to Low\n");
221 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
222 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
223 "[BTCoex], wifi RSSI state stay at Medium\n");
226 if (wifi_rssi < rssi_thresh1) {
227 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
228 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
229 "[BTCoex], wifi RSSI state switch to Medium\n");
231 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
232 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
233 "[BTCoex], wifi RSSI state stay at High\n");
238 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
240 return wifi_rssi_state;
244 void btc8723b2ant_limited_rx(struct btc_coexist *btcoexist, bool force_exec,
245 bool rej_ap_agg_pkt, bool bt_ctrl_agg_buf_size,
248 bool reject_rx_agg = rej_ap_agg_pkt;
249 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
250 u8 rx_agg_size = agg_buf_size;
252 /* ============================================ */
253 /* Rx Aggregation related setting */
254 /* ============================================ */
255 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
257 /* decide BT control aggregation buf size or not */
258 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
259 &bt_ctrl_rx_agg_size);
260 /* aggregate buf size, only work when BT control Rx aggregate size */
261 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
262 /* real update aggregation setting */
263 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
266 static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
268 struct rtl_priv *rtlpriv = btcoexist->adapter;
269 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
270 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
271 u32 reg_hp_tx = 0, reg_hp_rx = 0;
272 u32 reg_lp_tx = 0, reg_lp_rx = 0;
277 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
278 reg_hp_tx = u32tmp & MASKLWORD;
279 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
281 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
282 reg_lp_tx = u32tmp & MASKLWORD;
283 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
285 coex_sta->high_priority_tx = reg_hp_tx;
286 coex_sta->high_priority_rx = reg_hp_rx;
287 coex_sta->low_priority_tx = reg_lp_tx;
288 coex_sta->low_priority_rx = reg_lp_rx;
290 if ((coex_sta->low_priority_tx > 1050) &&
291 (!coex_sta->c2h_bt_inquiry_page))
292 coex_sta->pop_event_cnt++;
294 if ((coex_sta->low_priority_rx >= 950) &&
295 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
296 (!coex_sta->under_ips))
297 bt_link_info->slave_role = true;
299 bt_link_info->slave_role = false;
301 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
302 "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
303 reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
304 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
305 "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
306 reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
309 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
312 static void btc8723b2ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
314 if (coex_sta->under_ips) {
315 coex_sta->crc_ok_cck = 0;
316 coex_sta->crc_ok_11g = 0;
317 coex_sta->crc_ok_11n = 0;
318 coex_sta->crc_ok_11n_agg = 0;
320 coex_sta->crc_err_cck = 0;
321 coex_sta->crc_err_11g = 0;
322 coex_sta->crc_err_11n = 0;
323 coex_sta->crc_err_11n_agg = 0;
325 coex_sta->crc_ok_cck =
326 btcoexist->btc_read_4byte(btcoexist, 0xf88);
327 coex_sta->crc_ok_11g =
328 btcoexist->btc_read_2byte(btcoexist, 0xf94);
329 coex_sta->crc_ok_11n =
330 btcoexist->btc_read_2byte(btcoexist, 0xf90);
331 coex_sta->crc_ok_11n_agg =
332 btcoexist->btc_read_2byte(btcoexist, 0xfb8);
334 coex_sta->crc_err_cck =
335 btcoexist->btc_read_4byte(btcoexist, 0xf84);
336 coex_sta->crc_err_11g =
337 btcoexist->btc_read_2byte(btcoexist, 0xf96);
338 coex_sta->crc_err_11n =
339 btcoexist->btc_read_2byte(btcoexist, 0xf92);
340 coex_sta->crc_err_11n_agg =
341 btcoexist->btc_read_2byte(btcoexist, 0xfba);
345 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
346 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
349 static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist)
351 struct rtl_priv *rtlpriv = btcoexist->adapter;
352 u8 h2c_parameter[1] = {0};
354 coex_sta->c2h_bt_info_req_sent = true;
356 h2c_parameter[0] |= BIT0; /* trigger */
358 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
359 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
362 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
365 static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
367 static bool pre_wifi_busy;
368 static bool pre_under_4way;
369 static bool pre_bt_hs_on;
370 bool wifi_busy = false, under_4way = false, bt_hs_on = false;
371 bool wifi_connected = false;
372 u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
375 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
377 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
378 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
379 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
382 if (wifi_connected) {
383 if (wifi_busy != pre_wifi_busy) {
384 pre_wifi_busy = wifi_busy;
388 if (under_4way != pre_under_4way) {
389 pre_under_4way = under_4way;
393 if (bt_hs_on != pre_bt_hs_on) {
394 pre_bt_hs_on = bt_hs_on;
398 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
399 coex_dm->switch_thres_offset;
401 btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, tmp, 0);
403 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
404 (wifi_rssi_state == BTC_RSSI_STATE_LOW))
411 static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist)
413 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
414 bool bt_hs_on = false;
416 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
418 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
419 bt_link_info->sco_exist = coex_sta->sco_exist;
420 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
421 bt_link_info->pan_exist = coex_sta->pan_exist;
422 bt_link_info->hid_exist = coex_sta->hid_exist;
424 /* work around for HS mode. */
426 bt_link_info->pan_exist = true;
427 bt_link_info->bt_link_exist = true;
430 /* check if Sco only */
431 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
432 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
433 bt_link_info->sco_only = true;
435 bt_link_info->sco_only = false;
437 /* check if A2dp only */
438 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
439 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
440 bt_link_info->a2dp_only = true;
442 bt_link_info->a2dp_only = false;
444 /* check if Pan only */
445 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
446 bt_link_info->pan_exist && !bt_link_info->hid_exist)
447 bt_link_info->pan_only = true;
449 bt_link_info->pan_only = false;
451 /* check if Hid only */
452 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
453 !bt_link_info->pan_exist && bt_link_info->hid_exist)
454 bt_link_info->hid_only = true;
456 bt_link_info->hid_only = false;
459 static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
461 struct rtl_priv *rtlpriv = btcoexist->adapter;
462 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
463 bool bt_hs_on = false;
464 u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
465 u8 num_of_diff_profile = 0;
467 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
469 if (!bt_link_info->bt_link_exist) {
470 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
471 "[BTCoex], No BT link exists!!!\n");
475 if (bt_link_info->sco_exist)
476 num_of_diff_profile++;
477 if (bt_link_info->hid_exist)
478 num_of_diff_profile++;
479 if (bt_link_info->pan_exist)
480 num_of_diff_profile++;
481 if (bt_link_info->a2dp_exist)
482 num_of_diff_profile++;
484 if (num_of_diff_profile == 1) {
485 if (bt_link_info->sco_exist) {
486 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
487 "[BTCoex], SCO only\n");
488 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
490 if (bt_link_info->hid_exist) {
491 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
492 "[BTCoex], HID only\n");
493 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
494 } else if (bt_link_info->a2dp_exist) {
495 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
496 "[BTCoex], A2DP only\n");
497 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
498 } else if (bt_link_info->pan_exist) {
500 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
502 "[BTCoex], PAN(HS) only\n");
504 BT_8723B_2ANT_COEX_ALGO_PANHS;
506 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
508 "[BTCoex], PAN(EDR) only\n");
510 BT_8723B_2ANT_COEX_ALGO_PANEDR;
514 } else if (num_of_diff_profile == 2) {
515 if (bt_link_info->sco_exist) {
516 if (bt_link_info->hid_exist) {
517 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
518 "[BTCoex], SCO + HID\n");
519 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
520 } else if (bt_link_info->a2dp_exist) {
521 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
522 "[BTCoex], SCO + A2DP ==> SCO\n");
523 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
524 } else if (bt_link_info->pan_exist) {
526 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
528 "[BTCoex], SCO + PAN(HS)\n");
529 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
531 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
533 "[BTCoex], SCO + PAN(EDR)\n");
535 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
539 if (bt_link_info->hid_exist &&
540 bt_link_info->a2dp_exist) {
541 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
542 "[BTCoex], HID + A2DP\n");
543 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
544 } else if (bt_link_info->hid_exist &&
545 bt_link_info->pan_exist) {
547 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
549 "[BTCoex], HID + PAN(HS)\n");
550 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
552 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
554 "[BTCoex], HID + PAN(EDR)\n");
556 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
558 } else if (bt_link_info->pan_exist &&
559 bt_link_info->a2dp_exist) {
561 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
563 "[BTCoex], A2DP + PAN(HS)\n");
565 BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
567 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
569 "[BTCoex],A2DP + PAN(EDR)\n");
571 BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
575 } else if (num_of_diff_profile == 3) {
576 if (bt_link_info->sco_exist) {
577 if (bt_link_info->hid_exist &&
578 bt_link_info->a2dp_exist) {
579 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
580 "[BTCoex], SCO + HID + A2DP ==> HID\n");
581 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
582 } else if (bt_link_info->hid_exist &&
583 bt_link_info->pan_exist) {
585 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
587 "[BTCoex], SCO + HID + PAN(HS)\n");
589 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
591 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
593 "[BTCoex], SCO + HID + PAN(EDR)\n");
595 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
597 } else if (bt_link_info->pan_exist &&
598 bt_link_info->a2dp_exist) {
600 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
602 "[BTCoex], SCO + A2DP + PAN(HS)\n");
604 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
606 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
608 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
610 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
614 if (bt_link_info->hid_exist &&
615 bt_link_info->pan_exist &&
616 bt_link_info->a2dp_exist) {
618 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
620 "[BTCoex], HID + A2DP + PAN(HS)\n");
622 BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
624 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
626 "[BTCoex], HID + A2DP + PAN(EDR)\n");
628 BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
632 } else if (num_of_diff_profile >= 3) {
633 if (bt_link_info->sco_exist) {
634 if (bt_link_info->hid_exist &&
635 bt_link_info->pan_exist &&
636 bt_link_info->a2dp_exist) {
638 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
640 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
642 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
644 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
646 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
654 static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
657 struct rtl_priv *rtlpriv = btcoexist->adapter;
658 u8 h2c_parameter[1] = {0};
660 /* There are several type of dacswing
661 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
663 h2c_parameter[0] = dac_swing_lvl;
665 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
666 "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
667 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
668 "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
670 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
673 static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
676 struct rtl_priv *rtlpriv = btcoexist->adapter;
677 u8 h2c_parameter[1] = {0};
679 h2c_parameter[0] = dec_bt_pwr_lvl;
681 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
682 "[BTCoex], decrease Bt Power Level : %u\n", dec_bt_pwr_lvl);
684 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
687 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
688 bool force_exec, u8 dec_bt_pwr_lvl)
690 struct rtl_priv *rtlpriv = btcoexist->adapter;
692 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
693 "[BTCoex], Dec BT power level = %u\n", dec_bt_pwr_lvl);
694 coex_dm->cur_dec_bt_pwr_lvl = dec_bt_pwr_lvl;
697 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
698 "[BTCoex], PreDecBtPwrLvl=%d, CurDecBtPwrLvl=%d\n",
699 coex_dm->pre_dec_bt_pwr_lvl,
700 coex_dm->cur_dec_bt_pwr_lvl);
702 if (coex_dm->pre_dec_bt_pwr_lvl == coex_dm->cur_dec_bt_pwr_lvl)
705 btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr_lvl);
707 coex_dm->pre_dec_bt_pwr_lvl = coex_dm->cur_dec_bt_pwr_lvl;
711 void halbtc8723b2ant_set_bt_auto_report(struct btc_coexist *btcoexist,
712 bool enable_auto_report)
714 u8 h2c_parameter[1] = {0};
716 h2c_parameter[0] = 0;
718 if (enable_auto_report)
719 h2c_parameter[0] |= BIT(0);
721 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
725 void btc8723b2ant_bt_auto_report(struct btc_coexist *btcoexist,
726 bool force_exec, bool enable_auto_report)
728 coex_dm->cur_bt_auto_report = enable_auto_report;
731 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
734 halbtc8723b2ant_set_bt_auto_report(btcoexist,
735 coex_dm->cur_bt_auto_report);
737 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
740 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
741 bool force_exec, u8 fw_dac_swing_lvl)
743 struct rtl_priv *rtlpriv = btcoexist->adapter;
745 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
746 "[BTCoex], %s set FW Dac Swing level = %d\n",
747 (force_exec ? "force to" : ""), fw_dac_swing_lvl);
748 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
751 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
752 "[BTCoex], preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
753 coex_dm->pre_fw_dac_swing_lvl,
754 coex_dm->cur_fw_dac_swing_lvl);
756 if (coex_dm->pre_fw_dac_swing_lvl ==
757 coex_dm->cur_fw_dac_swing_lvl)
761 btc8723b2ant_set_fw_dac_swing_level(btcoexist,
762 coex_dm->cur_fw_dac_swing_lvl);
763 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
766 static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
769 struct rtl_priv *rtlpriv = btcoexist->adapter;
770 u8 h2c_parameter[6] = {0};
772 h2c_parameter[0] = 0x6; /* op_code, 0x6 = Retry_Penalty */
774 if (low_penalty_ra) {
775 h2c_parameter[1] |= BIT0;
776 /* normal rate except MCS7/6/5, OFDM54/48/36 */
777 h2c_parameter[2] = 0x00;
778 h2c_parameter[3] = 0xf4; /* MCS7 or OFDM54 */
779 h2c_parameter[4] = 0xf5; /* MCS6 or OFDM48 */
780 h2c_parameter[5] = 0xf6; /* MCS5 or OFDM36 */
783 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
784 "[BTCoex], set WiFi Low-Penalty Retry: %s",
785 (low_penalty_ra ? "ON!!" : "OFF!!"));
787 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
790 static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
791 bool force_exec, bool low_penalty_ra)
793 struct rtl_priv *rtlpriv = btcoexist->adapter;
795 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
796 "[BTCoex], %s turn LowPenaltyRA = %s\n",
797 (force_exec ? "force to" : ""), (low_penalty_ra ?
799 coex_dm->cur_low_penalty_ra = low_penalty_ra;
802 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
803 "[BTCoex], bPreLowPenaltyRa=%d, bCurLowPenaltyRa=%d\n",
804 coex_dm->pre_low_penalty_ra,
805 coex_dm->cur_low_penalty_ra);
807 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
810 btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra);
812 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
815 static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
818 struct rtl_priv *rtlpriv = btcoexist->adapter;
821 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
822 "[BTCoex], Write SwDacSwing = 0x%x\n", level);
823 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
826 static void btc8723b2ant_set_sw_fulltime_dac_swing(struct btc_coexist *btcoex,
827 bool sw_dac_swing_on,
828 u32 sw_dac_swing_lvl)
831 btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl);
833 btc8723b2ant_set_dac_swing_reg(btcoex, 0x18);
836 void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
837 bool force_exec, bool dac_swing_on,
840 struct rtl_priv *rtlpriv = btcoexist->adapter;
842 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
843 "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
844 (force_exec ? "force to" : ""),
845 (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
846 coex_dm->cur_dac_swing_on = dac_swing_on;
847 coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
850 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
851 "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x, bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
852 coex_dm->pre_dac_swing_on,
853 coex_dm->pre_dac_swing_lvl,
854 coex_dm->cur_dac_swing_on,
855 coex_dm->cur_dac_swing_lvl);
857 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
858 (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
862 btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on,
865 coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
866 coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
869 static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
870 u32 val0x6c0, u32 val0x6c4,
871 u32 val0x6c8, u8 val0x6cc)
873 struct rtl_priv *rtlpriv = btcoexist->adapter;
875 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
876 "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
877 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
879 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
880 "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
881 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
883 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
884 "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
885 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
887 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
888 "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
889 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
892 static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
893 bool force_exec, u32 val0x6c0,
894 u32 val0x6c4, u32 val0x6c8,
897 struct rtl_priv *rtlpriv = btcoexist->adapter;
899 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
900 "[BTCoex], %s write Coex Table 0x6c0=0x%x, 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
901 force_exec ? "force to" : "",
902 val0x6c0, val0x6c4, val0x6c8, val0x6cc);
903 coex_dm->cur_val0x6c0 = val0x6c0;
904 coex_dm->cur_val0x6c4 = val0x6c4;
905 coex_dm->cur_val0x6c8 = val0x6c8;
906 coex_dm->cur_val0x6cc = val0x6cc;
909 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
910 "[BTCoex], preVal0x6c0=0x%x, preVal0x6c4=0x%x, preVal0x6c8=0x%x, preVal0x6cc=0x%x !!\n",
911 coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
912 coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
913 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
914 "[BTCoex], curVal0x6c0=0x%x, curVal0x6c4=0x%x, curVal0x6c8=0x%x, curVal0x6cc=0x%x !!\n",
915 coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
916 coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
918 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
919 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
920 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
921 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
924 btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
927 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
928 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
929 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
930 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
933 static void btc8723b2ant_coex_table_with_type(struct btc_coexist *btcoexist,
934 bool force_exec, u8 type)
938 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
939 0x55555555, 0xffffff, 0x3);
942 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
943 0x5afa5afa, 0xffffff, 0x3);
946 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5ada5ada,
947 0x5ada5ada, 0xffffff, 0x3);
950 btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
951 0xaaaaaaaa, 0xffffff, 0x3);
954 btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff,
955 0xffffffff, 0xffffff, 0x3);
958 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
959 0x5fff5fff, 0xffffff, 0x3);
962 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
963 0x5a5a5a5a, 0xffffff, 0x3);
966 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
967 0x5ada5ada, 0xffffff, 0x3);
970 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
971 0x5ada5ada, 0xffffff, 0x3);
974 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
975 0x5ada5ada, 0xffffff, 0x3);
978 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
979 0x5ada5ada, 0xffffff, 0x3);
982 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
983 0x5ada5ada, 0xffffff, 0x3);
986 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
987 0x5ada5ada, 0xffffff, 0x3);
990 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
991 0xaaaaaaaa, 0xffffff, 0x3);
994 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
995 0x5ada5ada, 0xffffff, 0x3);
998 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
999 0xaaaaaaaa, 0xffffff, 0x3);
1006 static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
1009 struct rtl_priv *rtlpriv = btcoexist->adapter;
1010 u8 h2c_parameter[1] = {0};
1013 h2c_parameter[0] |= BIT0; /* function enable */
1015 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1016 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63=0x%x\n",
1019 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1022 static void btc8723b2ant_set_lps_rpwm(struct btc_coexist *btcoexist,
1023 u8 lps_val, u8 rpwm_val)
1028 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1029 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1032 static void btc8723b2ant_lps_rpwm(struct btc_coexist *btcoexist,
1033 bool force_exec, u8 lps_val, u8 rpwm_val)
1035 coex_dm->cur_lps = lps_val;
1036 coex_dm->cur_rpwm = rpwm_val;
1039 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1040 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1043 btc8723b2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1045 coex_dm->pre_lps = coex_dm->cur_lps;
1046 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1049 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1050 bool force_exec, bool enable)
1052 struct rtl_priv *rtlpriv = btcoexist->adapter;
1054 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1055 "[BTCoex], %s turn Ignore WlanAct %s\n",
1056 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1057 coex_dm->cur_ignore_wlan_act = enable;
1060 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1061 "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
1062 coex_dm->pre_ignore_wlan_act,
1063 coex_dm->cur_ignore_wlan_act);
1065 if (coex_dm->pre_ignore_wlan_act ==
1066 coex_dm->cur_ignore_wlan_act)
1069 btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1071 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1074 static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
1075 u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1077 struct rtl_priv *rtlpriv = btcoexist->adapter;
1078 u8 h2c_parameter[5];
1079 if ((coex_sta->a2dp_exist) && (coex_sta->hid_exist))
1080 byte5 = byte5 | 0x1;
1082 h2c_parameter[0] = byte1;
1083 h2c_parameter[1] = byte2;
1084 h2c_parameter[2] = byte3;
1085 h2c_parameter[3] = byte4;
1086 h2c_parameter[4] = byte5;
1088 coex_dm->ps_tdma_para[0] = byte1;
1089 coex_dm->ps_tdma_para[1] = byte2;
1090 coex_dm->ps_tdma_para[2] = byte3;
1091 coex_dm->ps_tdma_para[3] = byte4;
1092 coex_dm->ps_tdma_para[4] = byte5;
1094 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1095 "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
1097 h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1098 h2c_parameter[3] << 8 | h2c_parameter[4]);
1100 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1103 static void btc8723b2ant_sw_mechanism(struct btc_coexist *btcoexist,
1104 bool shrink_rx_lpf, bool low_penalty_ra,
1105 bool limited_dig, bool bt_lna_constrain)
1107 btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1110 static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
1111 u8 antpos_type, bool init_hwcfg,
1114 struct btc_board_info *board_info = &btcoexist->board_info;
1115 u32 fw_ver = 0, u32tmp = 0;
1116 bool pg_ext_switch = false;
1117 bool use_ext_switch = false;
1118 u8 h2c_parameter[2] = {0};
1120 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
1121 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
1123 if ((fw_ver < 0xc0000) || pg_ext_switch)
1124 use_ext_switch = true;
1127 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
1128 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
1129 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
1130 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
1131 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
1133 if (fw_ver >= 0x180000) {
1134 /* Use H2C to set GNT_BT to High to avoid A2DP click */
1135 h2c_parameter[0] = 1;
1136 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1139 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
1142 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
1144 /* WiFi TRx Mask off */
1145 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1148 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1149 /* tell firmware "no antenna inverse" */
1150 h2c_parameter[0] = 0;
1152 /* tell firmware "antenna inverse" */
1153 h2c_parameter[0] = 1;
1156 if (use_ext_switch) {
1157 /* ext switch type */
1158 h2c_parameter[1] = 1;
1160 /* int switch type */
1161 h2c_parameter[1] = 0;
1163 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, h2c_parameter);
1165 if (fw_ver >= 0x180000) {
1166 /* Use H2C to set GNT_BT to "Control by PTA"*/
1167 h2c_parameter[0] = 0;
1168 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1171 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
1175 /* ext switch setting */
1176 if (use_ext_switch) {
1178 /* 0x4c[23] = 0, 0x4c[24] = 1 Ant controlled by WL/BT */
1179 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1182 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1185 /* fixed internal switch S1->WiFi, S0->BT */
1186 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1187 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1189 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1191 switch (antpos_type) {
1192 case BTC_ANT_WIFI_AT_MAIN:
1193 /* ext switch main at wifi */
1194 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
1197 case BTC_ANT_WIFI_AT_AUX:
1198 /* ext switch aux at wifi */
1199 btcoexist->btc_write_1byte_bitmask(btcoexist,
1204 /* internal switch */
1206 /* 0x4c[23] = 0, 0x4c[24] = 1 Ant controlled by WL/BT */
1207 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1210 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1213 /* fixed ext switch, S1->Main, S0->Aux */
1214 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 0x0);
1215 switch (antpos_type) {
1216 case BTC_ANT_WIFI_AT_MAIN:
1217 /* fixed internal switch S1->WiFi, S0->BT */
1218 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1220 case BTC_ANT_WIFI_AT_AUX:
1221 /* fixed internal switch S0->WiFi, S1->BT */
1222 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1228 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
1229 bool turn_on, u8 type)
1231 struct rtl_priv *rtlpriv = btcoexist->adapter;
1232 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1233 u8 wifi_rssi_state, bt_rssi_state;
1234 s8 wifi_duration_adjust = 0x0;
1235 u8 tdma_byte4_modify = 0x0;
1236 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1237 coex_dm->switch_thres_offset;
1239 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, tmp, 0);
1240 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1241 coex_dm->switch_thres_offset;
1242 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
1244 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1245 "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1246 (force_exec ? "force to" : ""),
1247 (turn_on ? "ON" : "OFF"), type);
1248 coex_dm->cur_ps_tdma_on = turn_on;
1249 coex_dm->cur_ps_tdma = type;
1251 if (!(BTC_RSSI_HIGH(wifi_rssi_state) &&
1252 BTC_RSSI_HIGH(bt_rssi_state)) && turn_on) {
1253 /* for WiFi RSSI low or BT RSSI low */
1255 coex_dm->is_switch_to_1dot5_ant = true;
1257 coex_dm->is_switch_to_1dot5_ant = false;
1261 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1262 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1263 coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1264 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1265 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1266 coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1268 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1269 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1273 if (coex_sta->scan_ap_num <= 5) {
1274 if (coex_sta->a2dp_bit_pool >= 45)
1275 wifi_duration_adjust = -15;
1276 else if (coex_sta->a2dp_bit_pool >= 35)
1277 wifi_duration_adjust = -10;
1279 wifi_duration_adjust = 5;
1280 } else if (coex_sta->scan_ap_num <= 20) {
1281 if (coex_sta->a2dp_bit_pool >= 45)
1282 wifi_duration_adjust = -15;
1283 else if (coex_sta->a2dp_bit_pool >= 35)
1284 wifi_duration_adjust = -10;
1286 wifi_duration_adjust = 0;
1287 } else if (coex_sta->scan_ap_num <= 40) {
1288 if (coex_sta->a2dp_bit_pool >= 45)
1289 wifi_duration_adjust = -15;
1290 else if (coex_sta->a2dp_bit_pool >= 35)
1291 wifi_duration_adjust = -10;
1293 wifi_duration_adjust = -5;
1295 if (coex_sta->a2dp_bit_pool >= 45)
1296 wifi_duration_adjust = -15;
1297 else if (coex_sta->a2dp_bit_pool >= 35)
1298 wifi_duration_adjust = -10;
1300 wifi_duration_adjust = -10;
1303 if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1304 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1305 tdma_byte4_modify = 0x1;
1311 btc8723b2ant_set_fw_ps_tdma(
1312 btcoexist, 0xe3, 0x3c,
1313 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1316 btc8723b2ant_set_fw_ps_tdma(
1317 btcoexist, 0xe3, 0x2d,
1318 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1321 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1323 0x90 | tdma_byte4_modify);
1326 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1328 0x90 | tdma_byte4_modify);
1331 btc8723b2ant_set_fw_ps_tdma(
1332 btcoexist, 0xe3, 0x3c,
1333 0x3, 0x70, 0x90 | tdma_byte4_modify);
1336 btc8723b2ant_set_fw_ps_tdma(
1337 btcoexist, 0xe3, 0x2d,
1338 0x3, 0x70, 0x90 | tdma_byte4_modify);
1341 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1343 0x90 | tdma_byte4_modify);
1346 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1348 0x90 | tdma_byte4_modify);
1351 btc8723b2ant_set_fw_ps_tdma(
1352 btcoexist, 0xe3, 0x3c + wifi_duration_adjust,
1353 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1356 btc8723b2ant_set_fw_ps_tdma(
1357 btcoexist, 0xe3, 0x2d,
1358 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1361 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1363 0x90 | tdma_byte4_modify);
1366 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1368 0x90 | tdma_byte4_modify);
1371 btc8723b2ant_set_fw_ps_tdma(
1372 btcoexist, 0xe3, 0x3c,
1373 0x3, 0x70, 0x90 | tdma_byte4_modify);
1376 btc8723b2ant_set_fw_ps_tdma(
1377 btcoexist, 0xe3, 0x2d,
1378 0x3, 0x70, 0x90 | tdma_byte4_modify);
1381 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1383 0x90 | tdma_byte4_modify);
1386 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1388 0x90 | tdma_byte4_modify);
1391 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1395 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 0x5,
1399 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1403 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1407 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1413 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1417 btc8723b2ant_set_fw_ps_tdma(
1418 btcoexist, 0xe3, 0x3c + wifi_duration_adjust,
1425 btc8723b2ant_set_fw_ps_tdma(
1426 btcoexist, 0xd3, 0x3a + wifi_duration_adjust,
1427 0x03, 0x70, 0x50 | tdma_byte4_modify);
1433 btc8723b2ant_set_fw_ps_tdma(
1434 btcoexist, 0xd3, 0x2d + wifi_duration_adjust,
1435 0x03, 0x70, 0x50 | tdma_byte4_modify);
1441 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1443 0x50 | tdma_byte4_modify);
1449 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x10,
1451 0x50 | tdma_byte4_modify);
1454 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1456 0x90 | tdma_byte4_modify);
1459 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1461 0x90 | tdma_byte4_modify);
1465 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1470 /* disable PS tdma */
1473 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1477 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1481 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1487 /* update pre state */
1488 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1489 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1492 static void btc8723b2ant_ps_tdma_check_for_power_save_state(
1493 struct btc_coexist *btcoexist, bool new_ps_state)
1497 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1500 /* already under LPS state */
1502 /* keep state under LPS, do nothing. */
1504 /* will leave LPS state, turn off psTdma first */
1505 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1510 /* will enter LPS state, turn off psTdma first */
1511 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1513 /* keep state under NO PS state, do nothing. */
1518 static void btc8723b2ant_power_save_state(struct btc_coexist *btcoexist,
1519 u8 ps_type, u8 lps_val, u8 rpwm_val)
1521 bool low_pwr_disable = false;
1524 case BTC_PS_WIFI_NATIVE:
1525 /* recover to original 32k low power setting */
1526 low_pwr_disable = false;
1527 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1529 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1530 coex_sta->force_lps_on = false;
1533 btc8723b2ant_ps_tdma_check_for_power_save_state(btcoexist,
1535 btc8723b2ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1537 /* when coex force to enter LPS, do not enter 32k low power */
1538 low_pwr_disable = true;
1539 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1541 /* power save must executed before psTdma */
1542 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1543 coex_sta->force_lps_on = true;
1545 case BTC_PS_LPS_OFF:
1546 btc8723b2ant_ps_tdma_check_for_power_save_state(btcoexist,
1548 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1549 coex_sta->force_lps_on = false;
1556 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1559 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1560 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1561 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1562 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1565 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1568 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1569 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1572 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1574 /* force to reset coex mechanism*/
1575 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1576 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1578 btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1579 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1580 btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 0);
1582 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1584 coex_sta->pop_event_cnt = 0;
1587 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1589 struct rtl_priv *rtlpriv = btcoexist->adapter;
1590 bool wifi_connected = false;
1591 bool low_pwr_disable = true;
1592 bool scan = false, link = false, roam = false;
1594 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1596 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1599 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1600 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1601 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1603 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1605 if (coex_sta->bt_abnormal_scan) {
1606 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
1607 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
1608 } else if (scan || link || roam) {
1609 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1610 "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1611 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1612 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1613 } else if (wifi_connected) {
1614 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1615 "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1616 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1617 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1619 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1620 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1622 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1623 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1625 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1628 static void btc8723b2ant_action_wifi_link_process(struct btc_coexist
1631 struct rtl_priv *rtlpriv = btcoexist->adapter;
1635 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1636 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1638 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1640 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
1641 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1642 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1644 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1645 "[BTCoex], 0x948 = 0x%x, 0x765 = 0x%x, 0x76e = 0x%x\n",
1646 u32tmp, u8tmpa, u8tmpb);
1649 static bool btc8723b2ant_action_wifi_idle_process(struct btc_coexist *btcoexist)
1651 struct rtl_priv *rtlpriv = btcoexist->adapter;
1652 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1654 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1655 coex_dm->switch_thres_offset - coex_dm->switch_thres_offset;
1657 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1658 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
1660 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1661 coex_dm->switch_thres_offset - coex_dm->switch_thres_offset;
1662 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
1664 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1666 /* office environment */
1667 if (BTC_RSSI_HIGH(wifi_rssi_state1) && (coex_sta->hid_exist) &&
1668 (coex_sta->a2dp_exist)) {
1669 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1670 "[BTCoex], Wifi idle process for BT HID+A2DP exist!!\n");
1672 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1673 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1676 btc8723b2ant_sw_mechanism(btcoexist, false, false, false,
1678 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1679 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1681 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1686 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1690 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1692 struct rtl_priv *rtlpriv = btcoexist->adapter;
1693 bool common = false, wifi_connected = false;
1694 bool wifi_busy = false;
1695 bool bt_hs_on = false, low_pwr_disable = false;
1697 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1698 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1700 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1702 if (!wifi_connected) {
1703 low_pwr_disable = false;
1704 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1706 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1709 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1710 "[BTCoex], Wifi non-connected idle!!\n");
1712 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1714 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1715 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1716 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1717 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1719 btc8723b2ant_sw_mechanism(btcoexist, false, false, false,
1724 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1725 coex_dm->bt_status) {
1726 low_pwr_disable = false;
1727 btcoexist->btc_set(btcoexist,
1728 BTC_SET_ACT_DISABLE_LOW_POWER,
1730 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1733 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1734 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1736 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1738 btc8723b2ant_coex_table_with_type(btcoexist,
1740 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1741 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1743 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1745 btc8723b2ant_sw_mechanism(btcoexist, false, false,
1749 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1750 coex_dm->bt_status) {
1751 low_pwr_disable = true;
1752 btcoexist->btc_set(btcoexist,
1753 BTC_SET_ACT_DISABLE_LOW_POWER,
1758 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1759 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1760 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1763 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1765 btc8723b2ant_coex_table_with_type(btcoexist,
1767 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1768 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1770 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1772 btc8723b2ant_sw_mechanism(btcoexist, true, false,
1777 low_pwr_disable = true;
1778 btcoexist->btc_set(btcoexist,
1779 BTC_SET_ACT_DISABLE_LOW_POWER,
1783 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1784 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1787 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1788 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1791 btc8723b2ant_action_wifi_idle_process(
1800 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
1801 bool sco_hid, bool tx_pause,
1804 struct rtl_priv *rtlpriv = btcoexist->adapter;
1805 static s32 up, dn, m, n, wait_count;
1806 /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
1810 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1811 "[BTCoex], TdmaDurationAdjust()\n");
1813 if (!coex_dm->auto_tdma_adjust) {
1814 coex_dm->auto_tdma_adjust = true;
1815 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1816 "[BTCoex], first run TdmaDurationAdjust()!!\n");
1819 if (max_interval == 1) {
1820 btc8723b2ant_ps_tdma(btcoexist,
1823 coex_dm->ps_tdma_du_adj_type = 13;
1824 } else if (max_interval == 2) {
1825 btc8723b2ant_ps_tdma(btcoexist,
1828 coex_dm->ps_tdma_du_adj_type = 14;
1829 } else if (max_interval == 3) {
1830 btc8723b2ant_ps_tdma(btcoexist,
1833 coex_dm->ps_tdma_du_adj_type = 15;
1835 btc8723b2ant_ps_tdma(btcoexist,
1838 coex_dm->ps_tdma_du_adj_type = 15;
1841 if (max_interval == 1) {
1842 btc8723b2ant_ps_tdma(btcoexist,
1845 coex_dm->ps_tdma_du_adj_type = 9;
1846 } else if (max_interval == 2) {
1847 btc8723b2ant_ps_tdma(btcoexist,
1850 coex_dm->ps_tdma_du_adj_type = 10;
1851 } else if (max_interval == 3) {
1852 btc8723b2ant_ps_tdma(btcoexist,
1855 coex_dm->ps_tdma_du_adj_type = 11;
1857 btc8723b2ant_ps_tdma(btcoexist,
1860 coex_dm->ps_tdma_du_adj_type = 11;
1865 if (max_interval == 1) {
1866 btc8723b2ant_ps_tdma(btcoexist,
1869 coex_dm->ps_tdma_du_adj_type = 5;
1870 } else if (max_interval == 2) {
1871 btc8723b2ant_ps_tdma(btcoexist,
1874 coex_dm->ps_tdma_du_adj_type = 6;
1875 } else if (max_interval == 3) {
1876 btc8723b2ant_ps_tdma(btcoexist,
1879 coex_dm->ps_tdma_du_adj_type = 7;
1881 btc8723b2ant_ps_tdma(btcoexist,
1884 coex_dm->ps_tdma_du_adj_type = 7;
1887 if (max_interval == 1) {
1888 btc8723b2ant_ps_tdma(btcoexist,
1891 coex_dm->ps_tdma_du_adj_type = 1;
1892 } else if (max_interval == 2) {
1893 btc8723b2ant_ps_tdma(btcoexist,
1896 coex_dm->ps_tdma_du_adj_type = 2;
1897 } else if (max_interval == 3) {
1898 btc8723b2ant_ps_tdma(btcoexist,
1901 coex_dm->ps_tdma_du_adj_type = 3;
1903 btc8723b2ant_ps_tdma(btcoexist,
1906 coex_dm->ps_tdma_du_adj_type = 3;
1918 /*accquire the BT TRx retry count from BT_Info byte2*/
1919 retry_count = coex_sta->bt_retry_cnt;
1921 if ((coex_sta->low_priority_tx) > 1050 ||
1922 (coex_sta->low_priority_rx) > 1250)
1925 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1926 "[BTCoex], retry_count = %d\n", retry_count);
1927 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1928 "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
1929 up, dn, m, n, wait_count);
1932 /* no retry in the last 2-second duration*/
1933 if (retry_count == 0) {
1941 /* if retry count during continuous n*2
1942 * seconds is 0, enlarge WiFi duration
1949 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1950 "[BTCoex], Increase wifi duration!!\n");
1951 } /* <=3 retry in the last 2-second duration*/
1952 } else if (retry_count <= 3) {
1960 /* if continuous 2 retry count(every 2
1961 * seconds) >0 and < 3, reduce WiFi duration
1963 if (wait_count <= 2)
1964 /* avoid loop between the two levels */
1970 /* maximum of m = 20 ' will recheck if
1971 * need to adjust wifi duration in
1972 * maximum time interval 120 seconds
1981 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1982 "[BTCoex], Decrease wifi duration for retry_counter<3!!\n");
1985 /* retry count > 3, once retry count > 3, to reduce
1988 if (wait_count == 1)
1989 /* to avoid loop between the two levels */
1995 /* maximum of m = 20 ' will recheck if need to
1996 * adjust wifi duration in maximum time interval
2006 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2007 "[BTCoex], Decrease wifi duration for retry_counter>3!!\n");
2010 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2011 "[BTCoex], max Interval = %d\n", max_interval);
2012 if (max_interval == 1) {
2014 if (coex_dm->cur_ps_tdma == 71) {
2015 btc8723b2ant_ps_tdma(btcoexist,
2018 coex_dm->ps_tdma_du_adj_type = 5;
2019 } else if (coex_dm->cur_ps_tdma == 1) {
2020 btc8723b2ant_ps_tdma(btcoexist,
2023 coex_dm->ps_tdma_du_adj_type = 5;
2024 } else if (coex_dm->cur_ps_tdma == 2) {
2025 btc8723b2ant_ps_tdma(btcoexist,
2028 coex_dm->ps_tdma_du_adj_type = 6;
2029 } else if (coex_dm->cur_ps_tdma == 3) {
2030 btc8723b2ant_ps_tdma(btcoexist,
2033 coex_dm->ps_tdma_du_adj_type = 7;
2034 } else if (coex_dm->cur_ps_tdma == 4) {
2035 btc8723b2ant_ps_tdma(btcoexist,
2038 coex_dm->ps_tdma_du_adj_type = 8;
2040 if (coex_dm->cur_ps_tdma == 9) {
2041 btc8723b2ant_ps_tdma(btcoexist,
2044 coex_dm->ps_tdma_du_adj_type = 13;
2045 } else if (coex_dm->cur_ps_tdma == 10) {
2046 btc8723b2ant_ps_tdma(btcoexist,
2049 coex_dm->ps_tdma_du_adj_type = 14;
2050 } else if (coex_dm->cur_ps_tdma == 11) {
2051 btc8723b2ant_ps_tdma(btcoexist,
2054 coex_dm->ps_tdma_du_adj_type = 15;
2055 } else if (coex_dm->cur_ps_tdma == 12) {
2056 btc8723b2ant_ps_tdma(btcoexist,
2059 coex_dm->ps_tdma_du_adj_type = 16;
2063 if (coex_dm->cur_ps_tdma == 5) {
2064 btc8723b2ant_ps_tdma(
2065 btcoexist, NORMAL_EXEC,
2067 coex_dm->ps_tdma_du_adj_type =
2069 } else if (coex_dm->cur_ps_tdma == 6) {
2070 btc8723b2ant_ps_tdma(
2071 btcoexist, NORMAL_EXEC,
2073 coex_dm->ps_tdma_du_adj_type =
2075 } else if (coex_dm->cur_ps_tdma == 7) {
2076 btc8723b2ant_ps_tdma(
2077 btcoexist, NORMAL_EXEC,
2079 coex_dm->ps_tdma_du_adj_type =
2081 } else if (coex_dm->cur_ps_tdma == 13) {
2082 btc8723b2ant_ps_tdma(
2083 btcoexist, NORMAL_EXEC,
2085 coex_dm->ps_tdma_du_adj_type =
2087 } else if (coex_dm->cur_ps_tdma == 14) {
2088 btc8723b2ant_ps_tdma(
2089 btcoexist, NORMAL_EXEC,
2091 coex_dm->ps_tdma_du_adj_type =
2093 } else if (coex_dm->cur_ps_tdma == 15) {
2094 btc8723b2ant_ps_tdma(
2095 btcoexist, NORMAL_EXEC,
2097 coex_dm->ps_tdma_du_adj_type =
2100 } else if (result == 1) {
2101 if (coex_dm->cur_ps_tdma == 8) {
2102 btc8723b2ant_ps_tdma(
2103 btcoexist, NORMAL_EXEC,
2105 coex_dm->ps_tdma_du_adj_type =
2107 } else if (coex_dm->cur_ps_tdma == 7) {
2108 btc8723b2ant_ps_tdma(
2109 btcoexist, NORMAL_EXEC,
2111 coex_dm->ps_tdma_du_adj_type =
2113 } else if (coex_dm->cur_ps_tdma == 6) {
2114 btc8723b2ant_ps_tdma(
2115 btcoexist, NORMAL_EXEC,
2117 coex_dm->ps_tdma_du_adj_type =
2119 } else if (coex_dm->cur_ps_tdma == 16) {
2120 btc8723b2ant_ps_tdma(
2121 btcoexist, NORMAL_EXEC,
2123 coex_dm->ps_tdma_du_adj_type =
2125 } else if (coex_dm->cur_ps_tdma == 15) {
2126 btc8723b2ant_ps_tdma(
2127 btcoexist, NORMAL_EXEC,
2129 coex_dm->ps_tdma_du_adj_type =
2131 } else if (coex_dm->cur_ps_tdma == 14) {
2132 btc8723b2ant_ps_tdma(
2133 btcoexist, NORMAL_EXEC,
2135 coex_dm->ps_tdma_du_adj_type =
2140 if (coex_dm->cur_ps_tdma == 5) {
2141 btc8723b2ant_ps_tdma(btcoexist,
2144 coex_dm->ps_tdma_du_adj_type = 71;
2145 } else if (coex_dm->cur_ps_tdma == 6) {
2146 btc8723b2ant_ps_tdma(btcoexist,
2149 coex_dm->ps_tdma_du_adj_type = 2;
2150 } else if (coex_dm->cur_ps_tdma == 7) {
2151 btc8723b2ant_ps_tdma(btcoexist,
2154 coex_dm->ps_tdma_du_adj_type = 3;
2155 } else if (coex_dm->cur_ps_tdma == 8) {
2156 btc8723b2ant_ps_tdma(btcoexist,
2159 coex_dm->ps_tdma_du_adj_type = 4;
2161 if (coex_dm->cur_ps_tdma == 13) {
2162 btc8723b2ant_ps_tdma(btcoexist,
2165 coex_dm->ps_tdma_du_adj_type = 9;
2166 } else if (coex_dm->cur_ps_tdma == 14) {
2167 btc8723b2ant_ps_tdma(btcoexist,
2170 coex_dm->ps_tdma_du_adj_type = 10;
2171 } else if (coex_dm->cur_ps_tdma == 15) {
2172 btc8723b2ant_ps_tdma(btcoexist,
2175 coex_dm->ps_tdma_du_adj_type = 11;
2176 } else if (coex_dm->cur_ps_tdma == 16) {
2177 btc8723b2ant_ps_tdma(btcoexist,
2180 coex_dm->ps_tdma_du_adj_type = 12;
2184 if (coex_dm->cur_ps_tdma == 71) {
2185 btc8723b2ant_ps_tdma(
2186 btcoexist, NORMAL_EXEC,
2188 coex_dm->ps_tdma_du_adj_type =
2190 } else if (coex_dm->cur_ps_tdma == 1) {
2191 btc8723b2ant_ps_tdma(
2192 btcoexist, NORMAL_EXEC,
2194 coex_dm->ps_tdma_du_adj_type =
2196 } else if (coex_dm->cur_ps_tdma == 2) {
2197 btc8723b2ant_ps_tdma(
2198 btcoexist, NORMAL_EXEC,
2200 coex_dm->ps_tdma_du_adj_type =
2202 } else if (coex_dm->cur_ps_tdma == 3) {
2203 btc8723b2ant_ps_tdma(
2204 btcoexist, NORMAL_EXEC,
2206 coex_dm->ps_tdma_du_adj_type =
2208 } else if (coex_dm->cur_ps_tdma == 9) {
2209 btc8723b2ant_ps_tdma(
2210 btcoexist, NORMAL_EXEC,
2212 coex_dm->ps_tdma_du_adj_type =
2214 } else if (coex_dm->cur_ps_tdma == 10) {
2215 btc8723b2ant_ps_tdma(
2216 btcoexist, NORMAL_EXEC,
2218 coex_dm->ps_tdma_du_adj_type =
2220 } else if (coex_dm->cur_ps_tdma == 11) {
2221 btc8723b2ant_ps_tdma(
2222 btcoexist, NORMAL_EXEC,
2224 coex_dm->ps_tdma_du_adj_type =
2227 } else if (result == 1) {
2228 if (coex_dm->cur_ps_tdma == 4) {
2229 btc8723b2ant_ps_tdma(
2230 btcoexist, NORMAL_EXEC,
2232 coex_dm->ps_tdma_du_adj_type =
2234 } else if (coex_dm->cur_ps_tdma == 3) {
2235 btc8723b2ant_ps_tdma(
2236 btcoexist, NORMAL_EXEC,
2238 coex_dm->ps_tdma_du_adj_type =
2240 } else if (coex_dm->cur_ps_tdma == 2) {
2241 btc8723b2ant_ps_tdma(
2242 btcoexist, NORMAL_EXEC,
2244 coex_dm->ps_tdma_du_adj_type =
2246 } else if (coex_dm->cur_ps_tdma == 1) {
2247 btc8723b2ant_ps_tdma(
2248 btcoexist, NORMAL_EXEC,
2250 coex_dm->ps_tdma_du_adj_type =
2252 } else if (coex_dm->cur_ps_tdma == 12) {
2253 btc8723b2ant_ps_tdma(
2254 btcoexist, NORMAL_EXEC,
2256 coex_dm->ps_tdma_du_adj_type =
2258 } else if (coex_dm->cur_ps_tdma == 11) {
2259 btc8723b2ant_ps_tdma(
2260 btcoexist, NORMAL_EXEC,
2262 coex_dm->ps_tdma_du_adj_type =
2264 } else if (coex_dm->cur_ps_tdma == 10) {
2265 btc8723b2ant_ps_tdma(
2266 btcoexist, NORMAL_EXEC,
2268 coex_dm->ps_tdma_du_adj_type =
2273 } else if (max_interval == 2) {
2275 if (coex_dm->cur_ps_tdma == 1) {
2276 btc8723b2ant_ps_tdma(btcoexist,
2279 coex_dm->ps_tdma_du_adj_type = 6;
2280 } else if (coex_dm->cur_ps_tdma == 2) {
2281 btc8723b2ant_ps_tdma(btcoexist,
2284 coex_dm->ps_tdma_du_adj_type = 6;
2285 } else if (coex_dm->cur_ps_tdma == 3) {
2286 btc8723b2ant_ps_tdma(btcoexist,
2289 coex_dm->ps_tdma_du_adj_type = 7;
2290 } else if (coex_dm->cur_ps_tdma == 4) {
2291 btc8723b2ant_ps_tdma(btcoexist,
2294 coex_dm->ps_tdma_du_adj_type = 8;
2296 if (coex_dm->cur_ps_tdma == 9) {
2297 btc8723b2ant_ps_tdma(btcoexist,
2300 coex_dm->ps_tdma_du_adj_type = 14;
2301 } else if (coex_dm->cur_ps_tdma == 10) {
2302 btc8723b2ant_ps_tdma(btcoexist,
2305 coex_dm->ps_tdma_du_adj_type = 14;
2306 } else if (coex_dm->cur_ps_tdma == 11) {
2307 btc8723b2ant_ps_tdma(btcoexist,
2310 coex_dm->ps_tdma_du_adj_type = 15;
2311 } else if (coex_dm->cur_ps_tdma == 12) {
2312 btc8723b2ant_ps_tdma(btcoexist,
2315 coex_dm->ps_tdma_du_adj_type = 16;
2318 if (coex_dm->cur_ps_tdma == 5) {
2319 btc8723b2ant_ps_tdma(
2320 btcoexist, NORMAL_EXEC,
2322 coex_dm->ps_tdma_du_adj_type =
2324 } else if (coex_dm->cur_ps_tdma == 6) {
2325 btc8723b2ant_ps_tdma(
2326 btcoexist, NORMAL_EXEC,
2328 coex_dm->ps_tdma_du_adj_type =
2330 } else if (coex_dm->cur_ps_tdma == 7) {
2331 btc8723b2ant_ps_tdma(
2332 btcoexist, NORMAL_EXEC,
2334 coex_dm->ps_tdma_du_adj_type =
2336 } else if (coex_dm->cur_ps_tdma == 13) {
2337 btc8723b2ant_ps_tdma(
2338 btcoexist, NORMAL_EXEC,
2340 coex_dm->ps_tdma_du_adj_type =
2342 } else if (coex_dm->cur_ps_tdma == 14) {
2343 btc8723b2ant_ps_tdma(
2344 btcoexist, NORMAL_EXEC,
2346 coex_dm->ps_tdma_du_adj_type =
2348 } else if (coex_dm->cur_ps_tdma == 15) {
2349 btc8723b2ant_ps_tdma(
2350 btcoexist, NORMAL_EXEC,
2352 coex_dm->ps_tdma_du_adj_type =
2355 } else if (result == 1) {
2356 if (coex_dm->cur_ps_tdma == 8) {
2357 btc8723b2ant_ps_tdma(
2358 btcoexist, NORMAL_EXEC,
2360 coex_dm->ps_tdma_du_adj_type =
2362 } else if (coex_dm->cur_ps_tdma == 7) {
2363 btc8723b2ant_ps_tdma(
2364 btcoexist, NORMAL_EXEC,
2366 coex_dm->ps_tdma_du_adj_type =
2368 } else if (coex_dm->cur_ps_tdma == 6) {
2369 btc8723b2ant_ps_tdma(
2370 btcoexist, NORMAL_EXEC,
2372 coex_dm->ps_tdma_du_adj_type =
2374 } else if (coex_dm->cur_ps_tdma == 16) {
2375 btc8723b2ant_ps_tdma(
2376 btcoexist, NORMAL_EXEC,
2378 coex_dm->ps_tdma_du_adj_type =
2380 } else if (coex_dm->cur_ps_tdma == 15) {
2381 btc8723b2ant_ps_tdma(
2382 btcoexist, NORMAL_EXEC,
2384 coex_dm->ps_tdma_du_adj_type =
2386 } else if (coex_dm->cur_ps_tdma == 14) {
2387 btc8723b2ant_ps_tdma(
2388 btcoexist, NORMAL_EXEC,
2390 coex_dm->ps_tdma_du_adj_type =
2395 if (coex_dm->cur_ps_tdma == 5) {
2396 btc8723b2ant_ps_tdma(btcoexist,
2399 coex_dm->ps_tdma_du_adj_type = 2;
2400 } else if (coex_dm->cur_ps_tdma == 6) {
2401 btc8723b2ant_ps_tdma(btcoexist,
2404 coex_dm->ps_tdma_du_adj_type = 2;
2405 } else if (coex_dm->cur_ps_tdma == 7) {
2406 btc8723b2ant_ps_tdma(btcoexist,
2409 coex_dm->ps_tdma_du_adj_type = 3;
2410 } else if (coex_dm->cur_ps_tdma == 8) {
2411 btc8723b2ant_ps_tdma(btcoexist,
2414 coex_dm->ps_tdma_du_adj_type = 4;
2416 if (coex_dm->cur_ps_tdma == 13) {
2417 btc8723b2ant_ps_tdma(btcoexist,
2420 coex_dm->ps_tdma_du_adj_type = 10;
2421 } else if (coex_dm->cur_ps_tdma == 14) {
2422 btc8723b2ant_ps_tdma(btcoexist,
2425 coex_dm->ps_tdma_du_adj_type = 10;
2426 } else if (coex_dm->cur_ps_tdma == 15) {
2427 btc8723b2ant_ps_tdma(btcoexist,
2430 coex_dm->ps_tdma_du_adj_type = 11;
2431 } else if (coex_dm->cur_ps_tdma == 16) {
2432 btc8723b2ant_ps_tdma(btcoexist,
2435 coex_dm->ps_tdma_du_adj_type = 12;
2438 if (coex_dm->cur_ps_tdma == 1) {
2439 btc8723b2ant_ps_tdma(
2440 btcoexist, NORMAL_EXEC,
2442 coex_dm->ps_tdma_du_adj_type =
2444 } else if (coex_dm->cur_ps_tdma == 2) {
2445 btc8723b2ant_ps_tdma(
2446 btcoexist, NORMAL_EXEC,
2448 coex_dm->ps_tdma_du_adj_type =
2450 } else if (coex_dm->cur_ps_tdma == 3) {
2451 btc8723b2ant_ps_tdma(
2452 btcoexist, NORMAL_EXEC,
2454 coex_dm->ps_tdma_du_adj_type =
2456 } else if (coex_dm->cur_ps_tdma == 9) {
2457 btc8723b2ant_ps_tdma(
2458 btcoexist, NORMAL_EXEC,
2460 coex_dm->ps_tdma_du_adj_type =
2462 } else if (coex_dm->cur_ps_tdma == 10) {
2463 btc8723b2ant_ps_tdma(
2464 btcoexist, NORMAL_EXEC,
2466 coex_dm->ps_tdma_du_adj_type =
2468 } else if (coex_dm->cur_ps_tdma == 11) {
2469 btc8723b2ant_ps_tdma(
2470 btcoexist, NORMAL_EXEC,
2472 coex_dm->ps_tdma_du_adj_type =
2475 } else if (result == 1) {
2476 if (coex_dm->cur_ps_tdma == 4) {
2477 btc8723b2ant_ps_tdma(
2478 btcoexist, NORMAL_EXEC,
2480 coex_dm->ps_tdma_du_adj_type =
2482 } else if (coex_dm->cur_ps_tdma == 3) {
2483 btc8723b2ant_ps_tdma(
2484 btcoexist, NORMAL_EXEC,
2486 coex_dm->ps_tdma_du_adj_type =
2488 } else if (coex_dm->cur_ps_tdma == 2) {
2489 btc8723b2ant_ps_tdma(
2490 btcoexist, NORMAL_EXEC,
2492 coex_dm->ps_tdma_du_adj_type =
2494 } else if (coex_dm->cur_ps_tdma == 12) {
2495 btc8723b2ant_ps_tdma(
2496 btcoexist, NORMAL_EXEC,
2498 coex_dm->ps_tdma_du_adj_type =
2500 } else if (coex_dm->cur_ps_tdma == 11) {
2501 btc8723b2ant_ps_tdma(
2502 btcoexist, NORMAL_EXEC,
2504 coex_dm->ps_tdma_du_adj_type =
2506 } else if (coex_dm->cur_ps_tdma == 10) {
2507 btc8723b2ant_ps_tdma(
2508 btcoexist, NORMAL_EXEC,
2510 coex_dm->ps_tdma_du_adj_type =
2515 } else if (max_interval == 3) {
2517 if (coex_dm->cur_ps_tdma == 1) {
2518 btc8723b2ant_ps_tdma(btcoexist,
2521 coex_dm->ps_tdma_du_adj_type = 7;
2522 } else if (coex_dm->cur_ps_tdma == 2) {
2523 btc8723b2ant_ps_tdma(btcoexist,
2526 coex_dm->ps_tdma_du_adj_type = 7;
2527 } else if (coex_dm->cur_ps_tdma == 3) {
2528 btc8723b2ant_ps_tdma(btcoexist,
2531 coex_dm->ps_tdma_du_adj_type = 7;
2532 } else if (coex_dm->cur_ps_tdma == 4) {
2533 btc8723b2ant_ps_tdma(btcoexist,
2536 coex_dm->ps_tdma_du_adj_type = 8;
2538 if (coex_dm->cur_ps_tdma == 9) {
2539 btc8723b2ant_ps_tdma(btcoexist,
2542 coex_dm->ps_tdma_du_adj_type = 15;
2543 } else if (coex_dm->cur_ps_tdma == 10) {
2544 btc8723b2ant_ps_tdma(btcoexist,
2547 coex_dm->ps_tdma_du_adj_type = 15;
2548 } else if (coex_dm->cur_ps_tdma == 11) {
2549 btc8723b2ant_ps_tdma(btcoexist,
2552 coex_dm->ps_tdma_du_adj_type = 15;
2553 } else if (coex_dm->cur_ps_tdma == 12) {
2554 btc8723b2ant_ps_tdma(btcoexist,
2557 coex_dm->ps_tdma_du_adj_type = 16;
2560 if (coex_dm->cur_ps_tdma == 5) {
2561 btc8723b2ant_ps_tdma(
2562 btcoexist, NORMAL_EXEC,
2564 coex_dm->ps_tdma_du_adj_type =
2566 } else if (coex_dm->cur_ps_tdma == 6) {
2567 btc8723b2ant_ps_tdma(
2568 btcoexist, NORMAL_EXEC,
2570 coex_dm->ps_tdma_du_adj_type =
2572 } else if (coex_dm->cur_ps_tdma == 7) {
2573 btc8723b2ant_ps_tdma(
2574 btcoexist, NORMAL_EXEC,
2576 coex_dm->ps_tdma_du_adj_type =
2578 } else if (coex_dm->cur_ps_tdma == 13) {
2579 btc8723b2ant_ps_tdma(
2580 btcoexist, NORMAL_EXEC,
2582 coex_dm->ps_tdma_du_adj_type =
2584 } else if (coex_dm->cur_ps_tdma == 14) {
2585 btc8723b2ant_ps_tdma(
2586 btcoexist, NORMAL_EXEC,
2588 coex_dm->ps_tdma_du_adj_type =
2590 } else if (coex_dm->cur_ps_tdma == 15) {
2591 btc8723b2ant_ps_tdma(
2592 btcoexist, NORMAL_EXEC,
2594 coex_dm->ps_tdma_du_adj_type =
2597 } else if (result == 1) {
2598 if (coex_dm->cur_ps_tdma == 8) {
2599 btc8723b2ant_ps_tdma(
2600 btcoexist, NORMAL_EXEC,
2602 coex_dm->ps_tdma_du_adj_type =
2604 } else if (coex_dm->cur_ps_tdma == 7) {
2605 btc8723b2ant_ps_tdma(
2606 btcoexist, NORMAL_EXEC,
2608 coex_dm->ps_tdma_du_adj_type =
2610 } else if (coex_dm->cur_ps_tdma == 6) {
2611 btc8723b2ant_ps_tdma(
2612 btcoexist, NORMAL_EXEC,
2614 coex_dm->ps_tdma_du_adj_type =
2616 } else if (coex_dm->cur_ps_tdma == 16) {
2617 btc8723b2ant_ps_tdma(
2618 btcoexist, NORMAL_EXEC,
2620 coex_dm->ps_tdma_du_adj_type =
2622 } else if (coex_dm->cur_ps_tdma == 15) {
2623 btc8723b2ant_ps_tdma(
2624 btcoexist, NORMAL_EXEC,
2626 coex_dm->ps_tdma_du_adj_type =
2628 } else if (coex_dm->cur_ps_tdma == 14) {
2629 btc8723b2ant_ps_tdma(
2630 btcoexist, NORMAL_EXEC,
2632 coex_dm->ps_tdma_du_adj_type =
2637 if (coex_dm->cur_ps_tdma == 5) {
2638 btc8723b2ant_ps_tdma(btcoexist,
2641 coex_dm->ps_tdma_du_adj_type = 3;
2642 } else if (coex_dm->cur_ps_tdma == 6) {
2643 btc8723b2ant_ps_tdma(btcoexist,
2646 coex_dm->ps_tdma_du_adj_type = 3;
2647 } else if (coex_dm->cur_ps_tdma == 7) {
2648 btc8723b2ant_ps_tdma(btcoexist,
2651 coex_dm->ps_tdma_du_adj_type = 3;
2652 } else if (coex_dm->cur_ps_tdma == 8) {
2653 btc8723b2ant_ps_tdma(btcoexist,
2656 coex_dm->ps_tdma_du_adj_type = 4;
2658 if (coex_dm->cur_ps_tdma == 13) {
2659 btc8723b2ant_ps_tdma(btcoexist,
2662 coex_dm->ps_tdma_du_adj_type = 11;
2663 } else if (coex_dm->cur_ps_tdma == 14) {
2664 btc8723b2ant_ps_tdma(btcoexist,
2667 coex_dm->ps_tdma_du_adj_type = 11;
2668 } else if (coex_dm->cur_ps_tdma == 15) {
2669 btc8723b2ant_ps_tdma(btcoexist,
2672 coex_dm->ps_tdma_du_adj_type = 11;
2673 } else if (coex_dm->cur_ps_tdma == 16) {
2674 btc8723b2ant_ps_tdma(btcoexist,
2677 coex_dm->ps_tdma_du_adj_type = 12;
2680 if (coex_dm->cur_ps_tdma == 1) {
2681 btc8723b2ant_ps_tdma(
2682 btcoexist, NORMAL_EXEC,
2684 coex_dm->ps_tdma_du_adj_type =
2686 } else if (coex_dm->cur_ps_tdma == 2) {
2687 btc8723b2ant_ps_tdma(
2688 btcoexist, NORMAL_EXEC,
2690 coex_dm->ps_tdma_du_adj_type =
2692 } else if (coex_dm->cur_ps_tdma == 3) {
2693 btc8723b2ant_ps_tdma(
2694 btcoexist, NORMAL_EXEC,
2696 coex_dm->ps_tdma_du_adj_type =
2698 } else if (coex_dm->cur_ps_tdma == 9) {
2699 btc8723b2ant_ps_tdma(
2700 btcoexist, NORMAL_EXEC,
2702 coex_dm->ps_tdma_du_adj_type =
2704 } else if (coex_dm->cur_ps_tdma == 10) {
2705 btc8723b2ant_ps_tdma(
2706 btcoexist, NORMAL_EXEC,
2708 coex_dm->ps_tdma_du_adj_type =
2710 } else if (coex_dm->cur_ps_tdma == 11) {
2711 btc8723b2ant_ps_tdma(
2712 btcoexist, NORMAL_EXEC,
2714 coex_dm->ps_tdma_du_adj_type =
2717 } else if (result == 1) {
2718 if (coex_dm->cur_ps_tdma == 4) {
2719 btc8723b2ant_ps_tdma(
2720 btcoexist, NORMAL_EXEC,
2722 coex_dm->ps_tdma_du_adj_type =
2724 } else if (coex_dm->cur_ps_tdma == 3) {
2725 btc8723b2ant_ps_tdma(
2726 btcoexist, NORMAL_EXEC,
2728 coex_dm->ps_tdma_du_adj_type =
2730 } else if (coex_dm->cur_ps_tdma == 2) {
2731 btc8723b2ant_ps_tdma(
2732 btcoexist, NORMAL_EXEC,
2734 coex_dm->ps_tdma_du_adj_type =
2736 } else if (coex_dm->cur_ps_tdma == 12) {
2737 btc8723b2ant_ps_tdma(
2738 btcoexist, NORMAL_EXEC,
2740 coex_dm->ps_tdma_du_adj_type =
2742 } else if (coex_dm->cur_ps_tdma == 11) {
2743 btc8723b2ant_ps_tdma(
2744 btcoexist, NORMAL_EXEC,
2746 coex_dm->ps_tdma_du_adj_type =
2748 } else if (coex_dm->cur_ps_tdma == 10) {
2749 btc8723b2ant_ps_tdma(
2750 btcoexist, NORMAL_EXEC,
2752 coex_dm->ps_tdma_du_adj_type =
2760 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2761 "[BTCoex], max Interval = %d\n", max_interval);
2763 /* if current PsTdma not match with the recorded one (scan, dhcp, ...),
2764 * then we have to adjust it back to the previous recorded one.
2766 if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2767 bool scan = false, link = false, roam = false;
2768 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2769 "[BTCoex], PsTdma type dismatch!!!, curPsTdma=%d, recordPsTdma=%d\n",
2770 coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2772 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2773 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2774 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2776 if (!scan && !link && !roam)
2777 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2778 coex_dm->ps_tdma_du_adj_type);
2780 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2781 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2785 /* SCO only or SCO+PAN(HS) */
2786 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2788 u8 wifi_rssi_state, bt_rssi_state;
2791 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2792 bt_rssi_state = btc8723b2ant_bt_rssi_state(
2793 btcoexist, 2, BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2794 coex_dm->switch_thres_offset,
2797 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2799 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2800 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2802 if (BTC_RSSI_HIGH(bt_rssi_state))
2803 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2805 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2807 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2809 if (BTC_WIFI_BW_LEGACY == wifi_bw)
2810 /* for SCO quality at 11b/g mode */
2811 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2813 /* for SCO quality & wifi performance balance at 11n mode */
2814 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2816 /* for voice quality */
2817 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2820 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2821 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2822 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2823 btc8723b2ant_sw_mechanism(btcoexist, true, true,
2826 btc8723b2ant_sw_mechanism(btcoexist, true, true,
2830 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2831 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2832 btc8723b2ant_sw_mechanism(btcoexist, false, true,
2835 btc8723b2ant_sw_mechanism(btcoexist, false, true,
2841 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2843 u8 wifi_rssi_state, bt_rssi_state;
2845 u8 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2846 coex_dm->switch_thres_offset;
2848 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2849 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2851 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2853 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2854 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2856 if (BTC_RSSI_HIGH(bt_rssi_state))
2857 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2859 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2861 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2863 if (wifi_bw == BTC_WIFI_BW_LEGACY)
2864 /* for HID at 11b/g mode */
2865 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2867 /* for HID quality & wifi performance balance at 11n mode */
2868 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 9);
2870 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2872 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2873 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2874 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2876 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2879 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2880 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2881 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2882 btc8723b2ant_sw_mechanism(btcoexist, true, true,
2885 btc8723b2ant_sw_mechanism(btcoexist, true, true,
2889 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2890 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2891 btc8723b2ant_sw_mechanism(btcoexist, false, true,
2894 btc8723b2ant_sw_mechanism(btcoexist, false, true,
2900 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2901 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2903 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2906 u8 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2907 coex_dm->switch_thres_offset;
2909 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2910 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2, 40, 0);
2911 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2913 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
2915 /* define the office environment */
2916 /* driver don't know AP num in Linux, so we will never enter this if */
2917 if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) {
2918 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2920 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2921 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2922 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2923 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2926 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2927 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2928 btc8723b2ant_sw_mechanism(btcoexist, true, false,
2931 btc8723b2ant_sw_mechanism(btcoexist, false, false,
2937 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2938 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2940 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2942 if (BTC_RSSI_HIGH(bt_rssi_state))
2943 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2945 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2947 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2948 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2949 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2952 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2953 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2957 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2958 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2959 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2962 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2965 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2966 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2967 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2968 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2969 btc8723b2ant_sw_mechanism(btcoexist, true, false,
2972 btc8723b2ant_sw_mechanism(btcoexist, true, false,
2976 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2977 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2978 btc8723b2ant_sw_mechanism(btcoexist, false, false,
2981 btc8723b2ant_sw_mechanism(btcoexist, false, false,
2987 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2989 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2991 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
2992 coex_dm->switch_thres_offset;
2994 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2995 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
2997 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2998 coex_dm->switch_thres_offset;
2999 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3001 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3003 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3004 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3006 if (BTC_RSSI_HIGH(bt_rssi_state))
3007 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3009 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3011 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3012 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3013 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3016 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3017 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3021 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
3024 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3025 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3026 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3027 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3028 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3031 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3035 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3036 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3037 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3040 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3046 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
3048 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3050 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3051 coex_dm->switch_thres_offset;
3053 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3054 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3056 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3057 coex_dm->switch_thres_offset;
3058 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3060 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3062 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3063 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3065 if (BTC_RSSI_HIGH(bt_rssi_state))
3066 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3068 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3070 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3071 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 10);
3072 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3075 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3076 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3080 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3081 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
3082 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
3084 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
3087 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3088 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3089 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3090 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3091 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3094 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3098 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3099 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3100 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3103 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3110 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
3112 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3114 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3115 coex_dm->switch_thres_offset;
3117 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3118 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3120 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3121 coex_dm->switch_thres_offset;
3122 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3124 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3126 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3127 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3129 if (BTC_RSSI_HIGH(bt_rssi_state))
3130 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3132 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3134 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3135 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3137 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3138 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3139 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3140 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3141 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3144 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3148 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3149 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3150 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3153 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3159 /* PAN(EDR) + A2DP */
3160 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
3162 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3164 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3165 coex_dm->switch_thres_offset;
3167 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3168 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3170 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3171 coex_dm->switch_thres_offset;
3172 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3174 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3176 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3178 if (BTC_RSSI_HIGH(bt_rssi_state))
3179 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3181 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3183 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state))
3184 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3187 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3189 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3191 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3192 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3193 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
3194 if (BTC_WIFI_BW_HT40 == wifi_bw)
3195 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
3198 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
3201 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3202 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
3206 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3207 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3208 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3209 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3212 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3216 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3217 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3218 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3221 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3227 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
3229 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3231 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3232 coex_dm->switch_thres_offset;
3234 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3235 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3237 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3238 coex_dm->switch_thres_offset;
3239 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3240 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3242 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3244 if (BTC_RSSI_HIGH(bt_rssi_state))
3245 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3247 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3249 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3250 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3251 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3254 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3255 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3259 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3260 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3261 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3262 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3264 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3267 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3269 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3272 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
3274 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3275 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
3277 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
3281 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3282 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3283 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3284 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3287 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3291 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3292 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3293 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3296 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3302 /* HID + A2DP + PAN(EDR) */
3303 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
3305 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3307 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3308 coex_dm->switch_thres_offset;
3310 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3311 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3313 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3314 coex_dm->switch_thres_offset;
3315 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3317 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3319 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3320 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3322 if (BTC_RSSI_HIGH(bt_rssi_state))
3323 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3325 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3327 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3328 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3329 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3332 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3333 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3337 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3340 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3341 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3342 if (BTC_WIFI_BW_HT40 == wifi_bw)
3343 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3346 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3349 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3353 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3354 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3355 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3356 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3359 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3363 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3364 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3365 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3368 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3374 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3376 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3379 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3380 coex_dm->switch_thres_offset;
3382 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3383 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3385 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3386 coex_dm->switch_thres_offset;
3387 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 3, tmp, 37);
3389 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3391 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3392 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3394 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3396 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3397 if (BTC_RSSI_HIGH(bt_rssi_state))
3398 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3399 else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3400 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3402 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3404 /* only 802.11N mode we have to dec bt power to 4 degree */
3405 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3406 /* need to check ap Number of Not */
3408 btc8723b2ant_dec_bt_pwr(btcoexist,
3411 btc8723b2ant_dec_bt_pwr(btcoexist,
3413 } else if (BTC_RSSI_MEDIUM(bt_rssi_state)) {
3414 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3416 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3420 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3421 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3422 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3425 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3426 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3430 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3432 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3435 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3438 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 18);
3439 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
3440 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
3441 btcoexist->btc_write_4byte(btcoexist, 0x430, 0x0);
3442 btcoexist->btc_write_4byte(btcoexist, 0x434, 0x01010000);
3445 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3448 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3453 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3454 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3455 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3456 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3459 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3463 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3464 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3465 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3468 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3474 static void btc8723b2ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
3476 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3477 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3480 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
3483 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3485 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3486 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3489 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3491 struct rtl_priv *rtlpriv = btcoexist->adapter;
3493 u32 num_of_wifi_link = 0;
3494 u32 wifi_link_status = 0;
3495 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3496 bool miracast_plus_bt = false;
3497 bool scan = false, link = false, roam = false;
3499 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3500 "[BTCoex], RunCoexistMechanism()===>\n");
3502 if (btcoexist->manual_control) {
3503 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3504 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3508 if (coex_sta->under_ips) {
3509 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3510 "[BTCoex], wifi is under IPS !!!\n");
3514 algorithm = btc8723b2ant_action_algorithm(btcoexist);
3515 if (coex_sta->c2h_bt_inquiry_page &&
3516 (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
3517 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3518 "[BTCoex], BT is under inquiry/page scan !!\n");
3519 btc8723b2ant_action_bt_inquiry(btcoexist);
3523 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3524 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3525 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3527 if (scan || link || roam) {
3528 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3529 "[BTCoex], WiFi is under Link Process !!\n");
3530 btc8723b2ant_action_wifi_link_process(btcoexist);
3535 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3537 num_of_wifi_link = wifi_link_status >> 16;
3539 if ((num_of_wifi_link >= 2) ||
3540 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3541 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3542 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3543 num_of_wifi_link, wifi_link_status);
3545 if (bt_link_info->bt_link_exist)
3546 miracast_plus_bt = true;
3548 miracast_plus_bt = false;
3550 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3552 btc8723b2ant_action_wifi_multi_port(btcoexist);
3557 miracast_plus_bt = false;
3558 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3561 coex_dm->cur_algorithm = algorithm;
3562 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3563 "[BTCoex], Algorithm = %d\n",
3564 coex_dm->cur_algorithm);
3566 if (btc8723b2ant_is_common_action(btcoexist)) {
3567 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3568 "[BTCoex], Action 2-Ant common\n");
3569 coex_dm->auto_tdma_adjust = false;
3571 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3572 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3573 "[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n",
3574 coex_dm->pre_algorithm,
3575 coex_dm->cur_algorithm);
3576 coex_dm->auto_tdma_adjust = false;
3578 switch (coex_dm->cur_algorithm) {
3579 case BT_8723B_2ANT_COEX_ALGO_SCO:
3580 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3581 "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3582 btc8723b2ant_action_sco(btcoexist);
3584 case BT_8723B_2ANT_COEX_ALGO_HID:
3585 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3586 "[BTCoex], Action 2-Ant, algorithm = HID\n");
3587 btc8723b2ant_action_hid(btcoexist);
3589 case BT_8723B_2ANT_COEX_ALGO_A2DP:
3590 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3591 "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3592 btc8723b2ant_action_a2dp(btcoexist);
3594 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
3595 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3596 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3597 btc8723b2ant_action_a2dp_pan_hs(btcoexist);
3599 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
3600 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3601 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3602 btc8723b2ant_action_pan_edr(btcoexist);
3604 case BT_8723B_2ANT_COEX_ALGO_PANHS:
3605 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3606 "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3607 btc8723b2ant_action_pan_hs(btcoexist);
3609 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
3610 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3611 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3612 btc8723b2ant_action_pan_edr_a2dp(btcoexist);
3614 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
3615 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3616 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3617 btc8723b2ant_action_pan_edr_hid(btcoexist);
3619 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3620 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3621 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3622 btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
3624 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
3625 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3626 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3627 btc8723b2ant_action_hid_a2dp(btcoexist);
3630 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3631 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3632 btc8723b2ant_coex_alloff(btcoexist);
3635 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3639 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist)
3641 bool is_in_mp_mode = false;
3642 u8 h2c_parameter[2] = {0};
3645 /* set wlan_act to low */
3646 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3648 /* WiFi standby while GNT_BT 0 -> 1 */
3649 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
3651 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3652 if (fw_ver >= 0x180000) {
3653 /* Use H2C to set GNT_BT to HIGH */
3654 h2c_parameter[0] = 1;
3655 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
3657 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
3660 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
3663 /* BT select s0/s1 is controlled by BT */
3664 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
3666 /* BT select s0/s1 is controlled by WiFi */
3667 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
3670 /*********************************************************************
3671 * extern function start with ex_btc8723b2ant_
3672 *********************************************************************/
3673 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
3675 struct rtl_priv *rtlpriv = btcoexist->adapter;
3678 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3679 "[BTCoex], 2Ant Init HW Config!!\n");
3680 coex_dm->bt_rf0x1e_backup =
3681 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3683 /* 0x790[5:0] = 0x5 */
3684 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3687 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3689 /* Antenna config */
3690 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
3692 coex_sta->dis_ver_info_cnt = 0;
3695 btc8723b2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3697 /* Enable counter statistics */
3698 /* 0x76e[3] = 1, WLAN_ACT controlled by PTA */
3699 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3700 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3701 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3702 btcoexist->auto_report_2ant = true;
3705 void ex_btc8723b2ant_power_on_setting(struct btc_coexist *btcoexist)
3707 struct btc_board_info *board_info = &btcoexist->board_info;
3711 btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
3713 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly */
3714 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
3715 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT0 | BIT1);
3717 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
3719 if (btcoexist->chip_interface == BTC_INTF_USB) {
3720 /* fixed at S0 for USB interface */
3721 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
3723 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3724 if (board_info->single_ant_path == 0) {
3726 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3727 } else if (board_info->single_ant_path == 1) {
3729 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
3731 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
3736 void ex_btc8723b2ant_pre_load_firmware(struct btc_coexist *btcoexist)
3738 struct btc_board_info *board_info = &btcoexist->board_info;
3739 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
3742 * S0 or S1 setting and Local register setting(By this fw can get
3743 * ant number, S0/S1, ... info)
3745 * Local setting bit define
3746 * BIT0: "0" : no antenna inverse; "1" : antenna inverse
3747 * BIT1: "0" : internal switch; "1" : external switch
3748 * BIT2: "0" : one antenna; "1" : two antennas
3750 * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
3753 if (btcoexist->chip_interface == BTC_INTF_USB) {
3754 /* fixed at S0 for USB interface */
3755 u8tmp |= 0x1; /* antenna inverse */
3756 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3758 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3759 if (board_info->single_ant_path == 0) {
3760 } else if (board_info->single_ant_path == 1) {
3762 u8tmp |= 0x1; /* antenna inverse */
3765 if (btcoexist->chip_interface == BTC_INTF_PCI)
3766 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
3768 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3769 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
3774 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3776 struct rtl_priv *rtlpriv = btcoexist->adapter;
3778 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3779 "[BTCoex], Coex Mechanism Init!!\n");
3780 btc8723b2ant_init_coex_dm(btcoexist);
3783 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
3785 struct btc_board_info *board_info = &btcoexist->board_info;
3786 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3787 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3788 struct rtl_priv *rtlpriv = btcoexist->adapter;
3789 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3791 bool roam = false, scan = false;
3792 bool link = false, wifi_under_5g = false;
3793 bool bt_hs_on = false, wifi_busy = false;
3794 s32 wifi_rssi = 0, bt_hs_rssi = 0;
3795 u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3796 u8 wifi_dot11_chnl, wifi_hs_chnl;
3797 u32 fw_ver = 0, bt_patch_ver = 0;
3800 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3801 "\r\n ============[BT Coexist info]============");
3803 if (btcoexist->manual_control) {
3804 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3805 "\r\n ==========[Under Manual Control]============");
3806 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3807 "\r\n ==========================================");
3810 if (!board_info->bt_exist) {
3811 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3815 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3816 "Ant PG number/ Ant mechanism:",
3817 board_info->pg_ant_num, board_info->btdm_ant_num);
3819 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d",
3820 "BT stack/ hci ext ver",
3821 ((stack_info->profile_notified) ? "Yes" : "No"),
3822 stack_info->hci_version);
3824 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3825 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3826 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3827 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3828 "CoexVer/ FwVer/ PatchVer",
3829 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3830 fw_ver, bt_patch_ver, bt_patch_ver);
3832 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3833 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3835 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3837 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)",
3838 "Dot11 channel / HsChnl(HsMode)",
3839 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3841 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %3ph ",
3842 "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info);
3844 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3845 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3846 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3847 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d",
3848 "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num);
3850 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3851 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3852 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3853 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3854 "Wifi link/ roam/ scan", link, roam, scan);
3856 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3857 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3858 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3859 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3861 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ",
3862 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3863 ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
3864 (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))),
3865 ((!wifi_busy) ? "idle" :
3866 ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
3867 "uplink" : "downlink")));
3869 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d",
3871 bt_link_info->sco_exist, bt_link_info->hid_exist,
3872 bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3873 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3875 bt_info_ext = coex_sta->bt_info_ext;
3876 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3877 "BT Info A2DP rate",
3878 (bt_info_ext & BIT0) ? "Basic rate" : "EDR rate");
3880 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3881 if (coex_sta->bt_info_c2h_cnt[i]) {
3882 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3883 "\r\n %-35s = %7ph(%d)",
3884 glbt_info_src_8723b_2ant[i],
3885 coex_sta->bt_info_c2h[i],
3886 coex_sta->bt_info_c2h_cnt[i]);
3890 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3891 "PS state, IPS/LPS",
3892 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3893 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3894 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3897 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3898 "\r\n %-35s", "============[Sw mechanism]============");
3899 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ",
3900 "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3901 coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3902 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3903 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3904 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3905 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3908 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3909 "============[Fw mechanism]============");
3911 ps_tdma_case = coex_dm->cur_ps_tdma;
3912 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3913 "\r\n %-35s = %5ph case-%d (auto:%d)",
3914 "PS TDMA", coex_dm->ps_tdma_para,
3915 ps_tdma_case, coex_dm->auto_tdma_adjust);
3917 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ",
3918 "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr_lvl,
3919 coex_dm->cur_ignore_wlan_act);
3922 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3923 "============[Hw setting]============");
3925 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3926 "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3928 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3929 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3930 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3931 "0x778/0x880[29:25]", u8tmp[0],
3932 (u32tmp[0] & 0x3e000000) >> 25);
3934 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3935 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3936 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3937 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3938 "0x948/ 0x67[5] / 0x765",
3939 u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]);
3941 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3942 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3943 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3944 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3945 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3946 u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
3948 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3949 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3950 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3951 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3952 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3953 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3954 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3955 ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
3956 ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
3958 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3959 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3960 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3961 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3963 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3964 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3965 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3966 "0xc50(dig)/0x49c(null-drop)", u32tmp[0] & 0xff, u8tmp[0]);
3968 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3969 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3970 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3971 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3973 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3974 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3976 fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3977 ((u32tmp[1]&0xffff0000) >> 16) +
3978 (u32tmp[1] & 0xffff) +
3979 (u32tmp[2] & 0xffff) +
3980 ((u32tmp[3]&0xffff0000) >> 16) +
3981 (u32tmp[3] & 0xffff);
3982 fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3984 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3985 "OFDM-CCA/OFDM-FA/CCK-FA",
3986 u32tmp[0] & 0xffff, fa_ofdm, fa_cck);
3988 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3989 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3990 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3991 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3992 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3993 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3994 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3995 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3997 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3998 "0x770(high-pri rx/tx)",
3999 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
4000 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
4001 "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
4002 coex_sta->low_priority_tx);
4003 if (btcoexist->auto_report_2ant)
4004 btc8723b2ant_monitor_bt_ctr(btcoexist);
4005 btcoexist->btc_disp_dbg_msg(btcoexist,
4006 BTC_DBG_DISP_COEX_STATISTICS);
4009 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
4011 struct rtl_priv *rtlpriv = btcoexist->adapter;
4013 if (BTC_IPS_ENTER == type) {
4014 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4015 "[BTCoex], IPS ENTER notify\n");
4016 coex_sta->under_ips = true;
4017 btc8723b2ant_wifioff_hwcfg(btcoexist);
4018 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4019 btc8723b2ant_coex_alloff(btcoexist);
4020 } else if (BTC_IPS_LEAVE == type) {
4021 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4022 "[BTCoex], IPS LEAVE notify\n");
4023 coex_sta->under_ips = false;
4024 ex_btc8723b2ant_init_hwconfig(btcoexist);
4025 btc8723b2ant_init_coex_dm(btcoexist);
4026 btc8723b2ant_query_bt_info(btcoexist);
4030 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
4032 struct rtl_priv *rtlpriv = btcoexist->adapter;
4034 if (BTC_LPS_ENABLE == type) {
4035 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4036 "[BTCoex], LPS ENABLE notify\n");
4037 coex_sta->under_lps = true;
4038 } else if (BTC_LPS_DISABLE == type) {
4039 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4040 "[BTCoex], LPS DISABLE notify\n");
4041 coex_sta->under_lps = false;
4045 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
4047 struct rtl_priv *rtlpriv = btcoexist->adapter;
4051 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
4052 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
4053 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
4055 if (BTC_SCAN_START == type)
4056 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4057 "[BTCoex], SCAN START notify\n");
4058 else if (BTC_SCAN_FINISH == type)
4059 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4060 "[BTCoex], SCAN FINISH notify\n");
4061 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4062 &coex_sta->scan_ap_num);
4064 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4065 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x76e=0x%x\n",
4066 u32tmp, u8tmpa, u8tmpb);
4069 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
4071 struct rtl_priv *rtlpriv = btcoexist->adapter;
4073 if (BTC_ASSOCIATE_START == type)
4074 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4075 "[BTCoex], CONNECT START notify\n");
4076 else if (BTC_ASSOCIATE_FINISH == type)
4077 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4078 "[BTCoex], CONNECT FINISH notify\n");
4081 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
4084 struct rtl_priv *rtlpriv = btcoexist->adapter;
4085 u8 h2c_parameter[3] = {0};
4087 u8 wifi_central_chnl;
4090 if (BTC_MEDIA_CONNECT == type)
4091 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4092 "[BTCoex], MEDIA connect notify\n");
4094 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4095 "[BTCoex], MEDIA disconnect notify\n");
4097 /* only 2.4G we need to inform bt the chnl mask */
4098 btcoexist->btc_get(btcoexist,
4099 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
4100 if ((BTC_MEDIA_CONNECT == type) &&
4101 (wifi_central_chnl <= 14)) {
4102 h2c_parameter[0] = 0x1;
4103 h2c_parameter[1] = wifi_central_chnl;
4104 btcoexist->btc_get(btcoexist,
4105 BTC_GET_U4_WIFI_BW, &wifi_bw);
4106 if (wifi_bw == BTC_WIFI_BW_HT40) {
4107 h2c_parameter[2] = 0x30;
4109 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4112 h2c_parameter[2] = 0x30;
4114 h2c_parameter[2] = 0x20;
4118 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
4119 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
4120 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
4122 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4123 "[BTCoex], FW write 0x66=0x%x\n",
4124 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
4127 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
4130 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
4133 struct rtl_priv *rtlpriv = btcoexist->adapter;
4135 if (type == BTC_PACKET_DHCP)
4136 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4137 "[BTCoex], DHCP Packet notify\n");
4140 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
4141 u8 *tmpbuf, u8 length)
4143 struct rtl_priv *rtlpriv = btcoexist->adapter;
4145 u8 i, rsp_source = 0;
4146 bool bt_busy = false, limited_dig = false;
4147 bool wifi_connected = false;
4149 coex_sta->c2h_bt_info_req_sent = false;
4151 rsp_source = tmpbuf[0]&0xf;
4152 if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
4153 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
4154 coex_sta->bt_info_c2h_cnt[rsp_source]++;
4156 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4157 "[BTCoex], Bt info[%d], length=%d, hex data=[",
4158 rsp_source, length);
4159 for (i = 0; i < length; i++) {
4160 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
4162 bt_info = tmpbuf[i];
4163 if (i == length - 1)
4164 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4165 "0x%02x]\n", tmpbuf[i]);
4167 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4168 "0x%02x, ", tmpbuf[i]);
4171 if (btcoexist->manual_control) {
4172 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4173 "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
4177 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
4178 coex_sta->bt_retry_cnt =
4179 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
4181 if (coex_sta->bt_retry_cnt >= 1)
4182 coex_sta->pop_event_cnt++;
4185 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4187 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4189 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
4190 coex_sta->c2h_bt_remote_name_req = true;
4192 coex_sta->c2h_bt_remote_name_req = false;
4194 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49)
4195 coex_sta->a2dp_bit_pool =
4196 coex_sta->bt_info_c2h[rsp_source][6];
4198 coex_sta->a2dp_bit_pool = 0;
4200 /* Here we need to resend some wifi info to BT
4201 * because BT is reset and loss of the info.
4203 if ((coex_sta->bt_info_ext & BIT1)) {
4204 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4205 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
4206 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4209 ex_btc8723b2ant_media_status_notify(
4213 ex_btc8723b2ant_media_status_notify(
4215 BTC_MEDIA_DISCONNECT);
4218 if ((coex_sta->bt_info_ext & BIT3)) {
4219 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4220 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4221 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
4224 /* BT already NOT ignore Wlan active, do nothing here.*/
4226 if (!btcoexist->auto_report_2ant) {
4227 if (!(coex_sta->bt_info_ext & BIT4))
4228 btc8723b2ant_bt_auto_report(btcoexist,
4233 /* check BIT2 first ==> check if bt is under inquiry or page scan */
4234 if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
4235 coex_sta->c2h_bt_inquiry_page = true;
4237 coex_sta->c2h_bt_inquiry_page = false;
4239 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4240 /* set link exist status */
4241 coex_sta->bt_link_exist = false;
4242 coex_sta->pan_exist = false;
4243 coex_sta->a2dp_exist = false;
4244 coex_sta->hid_exist = false;
4245 coex_sta->sco_exist = false;
4247 /* connection exists */
4248 coex_sta->bt_link_exist = true;
4249 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
4250 coex_sta->pan_exist = true;
4252 coex_sta->pan_exist = false;
4253 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
4254 coex_sta->a2dp_exist = true;
4256 coex_sta->a2dp_exist = false;
4257 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
4258 coex_sta->hid_exist = true;
4260 coex_sta->hid_exist = false;
4261 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
4262 coex_sta->sco_exist = true;
4264 coex_sta->sco_exist = false;
4266 if ((!coex_sta->hid_exist) &&
4267 (!coex_sta->c2h_bt_inquiry_page) &&
4268 (!coex_sta->sco_exist)) {
4269 if (coex_sta->high_priority_tx +
4270 coex_sta->high_priority_rx >= 160) {
4271 coex_sta->hid_exist = true;
4272 bt_info = bt_info | 0x28;
4277 btc8723b2ant_update_bt_link_info(btcoexist);
4279 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4280 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
4281 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4282 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4283 /* connection exists but no busy */
4284 } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
4285 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
4286 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4287 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4288 } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
4289 (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
4290 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
4291 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4292 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4293 } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
4294 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
4295 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4296 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4298 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
4299 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4300 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4303 if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
4304 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
4305 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
4310 limited_dig = false;
4313 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4315 coex_dm->limited_dig = limited_dig;
4316 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4318 btc8723b2ant_run_coexist_mechanism(btcoexist);
4321 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
4323 struct rtl_priv *rtlpriv = btcoexist->adapter;
4325 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n");
4327 btc8723b2ant_wifioff_hwcfg(btcoexist);
4328 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4329 ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4332 void ex_btc8723b2ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
4334 struct rtl_priv *rtlpriv = btcoexist->adapter;
4336 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
4338 if (pnp_state == BTC_WIFI_PNP_SLEEP) {
4339 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4340 "[BTCoex], Pnp notify to SLEEP\n");
4342 /* Driver do not leave IPS/LPS when driver is going to sleep, so
4343 * BTCoexistence think wifi is still under IPS/LPS
4345 * BT should clear UnderIPS/UnderLPS state to avoid mismatch
4346 * state after wakeup.
4348 coex_sta->under_ips = false;
4349 coex_sta->under_lps = false;
4350 } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
4351 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4352 "[BTCoex], Pnp notify to WAKE UP\n");
4353 ex_btc8723b2ant_init_hwconfig(btcoexist);
4354 btc8723b2ant_init_coex_dm(btcoexist);
4355 btc8723b2ant_query_bt_info(btcoexist);
4359 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
4361 struct rtl_priv *rtlpriv = btcoexist->adapter;
4362 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
4364 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4365 "[BTCoex], ==========================Periodical===========================\n");
4367 if (coex_sta->dis_ver_info_cnt <= 5) {
4368 coex_sta->dis_ver_info_cnt += 1;
4369 if (coex_sta->dis_ver_info_cnt == 3) {
4370 /* Antenna config to set 0x765 = 0x0 (GNT_BT control by
4371 * PTA) after initial
4373 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4374 "[BTCoex], Set GNT_BT control by PTA\n");
4375 btc8723b2ant_set_ant_path(
4376 btcoexist, BTC_ANT_WIFI_AT_MAIN, false, false);
4380 if (!btcoexist->auto_report_2ant) {
4381 btc8723b2ant_query_bt_info(btcoexist);
4383 btc8723b2ant_monitor_bt_ctr(btcoexist);
4384 btc8723b2ant_monitor_wifi_ctr(btcoexist);
4386 /* for some BT speakers that High-Priority pkts appear before
4387 * playing, this will cause HID exist
4389 if ((coex_sta->high_priority_tx +
4390 coex_sta->high_priority_rx < 50) &&
4391 (bt_link_info->hid_exist))
4392 bt_link_info->hid_exist = false;
4394 if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
4395 coex_dm->auto_tdma_adjust)
4396 btc8723b2ant_run_coexist_mechanism(btcoexist);