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 *****************************************************************************/
26 /***************************************************************
29 * This file is for RTL8723B Co-exist mechanism
32 * 2012/11/15 Cosa first check in.
34 ***************************************************************/
36 /***************************************************************
38 ***************************************************************/
39 #include "halbt_precomp.h"
40 /***************************************************************
41 * Global variables, these are static variables
42 ***************************************************************/
43 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant
;
44 static struct coex_dm_8723b_1ant
*coex_dm
= &glcoex_dm_8723b_1ant
;
45 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant
;
46 static struct coex_sta_8723b_1ant
*coex_sta
= &glcoex_sta_8723b_1ant
;
48 static const char *const GLBtInfoSrc8723b1Ant
[] = {
51 "BT Info[bt auto report]",
54 static u32 glcoex_ver_date_8723b_1ant
= 20130918;
55 static u32 glcoex_ver_8723b_1ant
= 0x47;
57 /***************************************************************
58 * local function proto type if needed
59 ***************************************************************/
60 /***************************************************************
61 * local function start with halbtc8723b1ant_
62 ***************************************************************/
63 static u8
halbtc8723b1ant_bt_rssi_state(u8 level_num
, u8 rssi_thresh
,
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_1ANT
) {
76 bt_rssi_state
= BTC_RSSI_STATE_HIGH
;
77 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
78 "[BTCoex], BT Rssi state switch to High\n");
80 bt_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
81 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
82 "[BTCoex], BT Rssi state stay at Low\n");
85 if (bt_rssi
< rssi_thresh
) {
86 bt_rssi_state
= BTC_RSSI_STATE_LOW
;
87 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
88 "[BTCoex], BT Rssi state switch to Low\n");
90 bt_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
91 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
92 "[BTCoex], BT Rssi state stay at High\n");
95 } else if (level_num
== 3) {
96 if (rssi_thresh
> rssi_thresh1
) {
97 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
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_1ANT
) {
106 bt_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
107 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
108 "[BTCoex], BT Rssi state switch to Medium\n");
110 bt_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
111 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
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_1ANT
) {
120 bt_rssi_state
= BTC_RSSI_STATE_HIGH
;
121 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
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 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
126 "[BTCoex], BT Rssi state switch to Low\n");
128 bt_rssi_state
= BTC_RSSI_STATE_STAY_MEDIUM
;
129 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
130 "[BTCoex], BT Rssi state stay at Medium\n");
133 if (bt_rssi
< rssi_thresh1
) {
134 bt_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
135 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
136 "[BTCoex], BT Rssi state switch to Medium\n");
138 bt_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
139 btc_alg_dbg(ALGO_BT_RSSI_STATE
,
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
halbtc8723b1ant_wifi_rssi_state(struct btc_coexist
*btcoexist
,
151 u8 index
, u8 level_num
,
152 u8 rssi_thresh
, u8 rssi_thresh1
)
155 u8 wifi_rssi_state
= coex_sta
->pre_wifi_rssi_state
[index
];
157 btcoexist
->btc_get(btcoexist
,
158 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_1ANT
) {
167 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
168 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
169 "[BTCoex], wifi RSSI state switch to High\n");
171 wifi_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
172 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
173 "[BTCoex], wifi RSSI state stay at Low\n");
176 if (wifi_rssi
< rssi_thresh
) {
177 wifi_rssi_state
= BTC_RSSI_STATE_LOW
;
178 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
179 "[BTCoex], wifi RSSI state switch to Low\n");
181 wifi_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
182 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
183 "[BTCoex], wifi RSSI state stay at High\n");
186 } else if (level_num
== 3) {
187 if (rssi_thresh
> rssi_thresh1
) {
188 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
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_1ANT
) {
199 wifi_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
200 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
201 "[BTCoex], wifi RSSI state switch to Medium\n");
203 wifi_rssi_state
= BTC_RSSI_STATE_STAY_LOW
;
204 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
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_1ANT
) {
213 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
214 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
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 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
219 "[BTCoex], wifi RSSI state switch to Low\n");
221 wifi_rssi_state
= BTC_RSSI_STATE_STAY_MEDIUM
;
222 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
223 "[BTCoex], wifi RSSI state stay at Medium\n");
226 if (wifi_rssi
< rssi_thresh1
) {
227 wifi_rssi_state
= BTC_RSSI_STATE_MEDIUM
;
228 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
229 "[BTCoex], wifi RSSI state switch to Medium\n");
231 wifi_rssi_state
= BTC_RSSI_STATE_STAY_HIGH
;
232 btc_alg_dbg(ALGO_WIFI_RSSI_STATE
,
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
;
243 static void halbtc8723b1ant_updatera_mask(struct btc_coexist
*btcoexist
,
244 bool force_exec
, u32 dis_rate_mask
)
246 coex_dm
->curra_mask
= dis_rate_mask
;
248 if (force_exec
|| (coex_dm
->prera_mask
!= coex_dm
->curra_mask
))
249 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_UPDATE_ra_mask
,
250 &coex_dm
->curra_mask
);
252 coex_dm
->prera_mask
= coex_dm
->curra_mask
;
255 static void btc8723b1ant_auto_rate_fb_retry(struct btc_coexist
*btcoexist
,
256 bool force_exec
, u8 type
)
258 bool wifi_under_bmode
= false;
260 coex_dm
->cur_arfr_type
= type
;
262 if (force_exec
|| (coex_dm
->pre_arfr_type
!= coex_dm
->cur_arfr_type
)) {
263 switch (coex_dm
->cur_arfr_type
) {
264 case 0: /* normal mode */
265 btcoexist
->btc_write_4byte(btcoexist
, 0x430,
266 coex_dm
->backup_arfr_cnt1
);
267 btcoexist
->btc_write_4byte(btcoexist
, 0x434,
268 coex_dm
->backup_arfr_cnt2
);
271 btcoexist
->btc_get(btcoexist
,
272 BTC_GET_BL_WIFI_UNDER_B_MODE
,
274 if (wifi_under_bmode
) {
275 btcoexist
->btc_write_4byte(btcoexist
,
277 btcoexist
->btc_write_4byte(btcoexist
,
280 btcoexist
->btc_write_4byte(btcoexist
,
282 btcoexist
->btc_write_4byte(btcoexist
,
291 coex_dm
->pre_arfr_type
= coex_dm
->cur_arfr_type
;
294 static void halbtc8723b1ant_retry_limit(struct btc_coexist
*btcoexist
,
295 bool force_exec
, u8 type
)
297 coex_dm
->cur_retry_limit_type
= type
;
299 if (force_exec
|| (coex_dm
->pre_retry_limit_type
!=
300 coex_dm
->cur_retry_limit_type
)) {
301 switch (coex_dm
->cur_retry_limit_type
) {
302 case 0: /* normal mode */
303 btcoexist
->btc_write_2byte(btcoexist
, 0x42a,
304 coex_dm
->backup_retry_limit
);
306 case 1: /* retry limit = 8 */
307 btcoexist
->btc_write_2byte(btcoexist
, 0x42a, 0x0808);
314 coex_dm
->pre_retry_limit_type
= coex_dm
->cur_retry_limit_type
;
317 static void halbtc8723b1ant_ampdu_maxtime(struct btc_coexist
*btcoexist
,
318 bool force_exec
, u8 type
)
320 coex_dm
->cur_ampdu_time_type
= type
;
322 if (force_exec
|| (coex_dm
->pre_ampdu_time_type
!=
323 coex_dm
->cur_ampdu_time_type
)) {
324 switch (coex_dm
->cur_ampdu_time_type
) {
325 case 0: /* normal mode */
326 btcoexist
->btc_write_1byte(btcoexist
, 0x456,
327 coex_dm
->backup_ampdu_max_time
);
329 case 1: /* AMPDU timw = 0x38 * 32us */
330 btcoexist
->btc_write_1byte(btcoexist
,
338 coex_dm
->pre_ampdu_time_type
= coex_dm
->cur_ampdu_time_type
;
341 static void halbtc8723b1ant_limited_tx(struct btc_coexist
*btcoexist
,
342 bool force_exec
, u8 ra_masktype
,
343 u8 arfr_type
, u8 retry_limit_type
,
346 switch (ra_masktype
) {
347 case 0: /* normal mode */
348 halbtc8723b1ant_updatera_mask(btcoexist
, force_exec
, 0x0);
350 case 1: /* disable cck 1/2 */
351 halbtc8723b1ant_updatera_mask(btcoexist
, force_exec
,
354 /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4*/
356 halbtc8723b1ant_updatera_mask(btcoexist
, force_exec
,
363 btc8723b1ant_auto_rate_fb_retry(btcoexist
, force_exec
, arfr_type
);
364 halbtc8723b1ant_retry_limit(btcoexist
, force_exec
, retry_limit_type
);
365 halbtc8723b1ant_ampdu_maxtime(btcoexist
, force_exec
, ampdu_time_type
);
368 static void halbtc8723b1ant_limited_rx(struct btc_coexist
*btcoexist
,
369 bool force_exec
, bool rej_ap_agg_pkt
,
370 bool bt_ctrl_agg_buf_size
,
373 bool reject_rx_agg
= rej_ap_agg_pkt
;
374 bool bt_ctrl_rx_agg_size
= bt_ctrl_agg_buf_size
;
375 u8 rxaggsize
= agg_buf_size
;
377 /**********************************************
378 * Rx Aggregation related setting
379 **********************************************/
380 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_TO_REJ_AP_AGG_PKT
,
382 /* decide BT control aggregation buf size or not */
383 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_CTRL_AGG_SIZE
,
384 &bt_ctrl_rx_agg_size
);
385 /* aggregation buf size, only work
386 * when BT control Rx aggregation size.
388 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_AGG_BUF_SIZE
, &rxaggsize
);
389 /* real update aggregation setting */
390 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_AGGREGATE_CTRL
, NULL
);
393 static void halbtc8723b1ant_monitor_bt_ctr(struct btc_coexist
*btcoexist
)
395 u32 reg_hp_txrx
, reg_lp_txrx
, u32tmp
;
396 u32 reg_hp_tx
= 0, reg_hp_rx
= 0;
397 u32 reg_lp_tx
= 0, reg_lp_rx
= 0;
402 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, reg_hp_txrx
);
403 reg_hp_tx
= u32tmp
& MASKLWORD
;
404 reg_hp_rx
= (u32tmp
& MASKHWORD
) >> 16;
406 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, reg_lp_txrx
);
407 reg_lp_tx
= u32tmp
& MASKLWORD
;
408 reg_lp_rx
= (u32tmp
& MASKHWORD
) >> 16;
410 coex_sta
->high_priority_tx
= reg_hp_tx
;
411 coex_sta
->high_priority_rx
= reg_hp_rx
;
412 coex_sta
->low_priority_tx
= reg_lp_tx
;
413 coex_sta
->low_priority_rx
= reg_lp_rx
;
416 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0xc);
419 static void halbtc8723b1ant_query_bt_info(struct btc_coexist
*btcoexist
)
421 u8 h2c_parameter
[1] = {0};
423 coex_sta
->c2h_bt_info_req_sent
= true;
425 h2c_parameter
[0] |= BIT0
; /* trigger*/
427 btc_alg_dbg(ALGO_TRACE_FW_EXEC
,
428 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
431 btcoexist
->btc_fill_h2c(btcoexist
, 0x61, 1, h2c_parameter
);
434 static bool btc8723b1ant_is_wifi_status_changed(struct btc_coexist
*btcoexist
)
436 static bool pre_wifi_busy
;
437 static bool pre_under_4way
, pre_bt_hs_on
;
438 bool wifi_busy
= false, under_4way
= false, bt_hs_on
= false;
439 bool wifi_connected
= false;
441 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
443 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
444 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
445 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_4_WAY_PROGRESS
,
448 if (wifi_connected
) {
449 if (wifi_busy
!= pre_wifi_busy
) {
450 pre_wifi_busy
= wifi_busy
;
453 if (under_4way
!= pre_under_4way
) {
454 pre_under_4way
= under_4way
;
457 if (bt_hs_on
!= pre_bt_hs_on
) {
458 pre_bt_hs_on
= bt_hs_on
;
466 static void halbtc8723b1ant_update_bt_link_info(struct btc_coexist
*btcoexist
)
468 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
469 bool bt_hs_on
= false;
471 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
473 bt_link_info
->bt_link_exist
= coex_sta
->bt_link_exist
;
474 bt_link_info
->sco_exist
= coex_sta
->sco_exist
;
475 bt_link_info
->a2dp_exist
= coex_sta
->a2dp_exist
;
476 bt_link_info
->pan_exist
= coex_sta
->pan_exist
;
477 bt_link_info
->hid_exist
= coex_sta
->hid_exist
;
479 /* work around for HS mode. */
481 bt_link_info
->pan_exist
= true;
482 bt_link_info
->bt_link_exist
= true;
485 /* check if Sco only */
486 if (bt_link_info
->sco_exist
&& !bt_link_info
->a2dp_exist
&&
487 !bt_link_info
->pan_exist
&& !bt_link_info
->hid_exist
)
488 bt_link_info
->sco_only
= true;
490 bt_link_info
->sco_only
= false;
492 /* check if A2dp only */
493 if (!bt_link_info
->sco_exist
&& bt_link_info
->a2dp_exist
&&
494 !bt_link_info
->pan_exist
&& !bt_link_info
->hid_exist
)
495 bt_link_info
->a2dp_only
= true;
497 bt_link_info
->a2dp_only
= false;
499 /* check if Pan only */
500 if (!bt_link_info
->sco_exist
&& !bt_link_info
->a2dp_exist
&&
501 bt_link_info
->pan_exist
&& !bt_link_info
->hid_exist
)
502 bt_link_info
->pan_only
= true;
504 bt_link_info
->pan_only
= false;
506 /* check if Hid only */
507 if (!bt_link_info
->sco_exist
&& !bt_link_info
->a2dp_exist
&&
508 !bt_link_info
->pan_exist
&& bt_link_info
->hid_exist
)
509 bt_link_info
->hid_only
= true;
511 bt_link_info
->hid_only
= false;
514 static u8
halbtc8723b1ant_action_algorithm(struct btc_coexist
*btcoexist
)
516 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
517 bool bt_hs_on
= false;
518 u8 algorithm
= BT_8723B_1ANT_COEX_ALGO_UNDEFINED
;
519 u8 numdiffprofile
= 0;
521 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
523 if (!bt_link_info
->bt_link_exist
) {
524 btc_alg_dbg(ALGO_TRACE
,
525 "[BTCoex], No BT link exists!!!\n");
529 if (bt_link_info
->sco_exist
)
531 if (bt_link_info
->hid_exist
)
533 if (bt_link_info
->pan_exist
)
535 if (bt_link_info
->a2dp_exist
)
538 if (numdiffprofile
== 1) {
539 if (bt_link_info
->sco_exist
) {
540 btc_alg_dbg(ALGO_TRACE
,
541 "[BTCoex], BT Profile = SCO only\n");
542 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
544 if (bt_link_info
->hid_exist
) {
545 btc_alg_dbg(ALGO_TRACE
,
546 "[BTCoex], BT Profile = HID only\n");
547 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID
;
548 } else if (bt_link_info
->a2dp_exist
) {
549 btc_alg_dbg(ALGO_TRACE
,
550 "[BTCoex], BT Profile = A2DP only\n");
551 algorithm
= BT_8723B_1ANT_COEX_ALGO_A2DP
;
552 } else if (bt_link_info
->pan_exist
) {
554 btc_alg_dbg(ALGO_TRACE
,
555 "[BTCoex], BT Profile = PAN(HS) only\n");
557 BT_8723B_1ANT_COEX_ALGO_PANHS
;
559 btc_alg_dbg(ALGO_TRACE
,
560 "[BTCoex], BT Profile = PAN(EDR) only\n");
562 BT_8723B_1ANT_COEX_ALGO_PANEDR
;
566 } else if (numdiffprofile
== 2) {
567 if (bt_link_info
->sco_exist
) {
568 if (bt_link_info
->hid_exist
) {
569 btc_alg_dbg(ALGO_TRACE
,
570 "[BTCoex], BT Profile = SCO + HID\n");
571 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID
;
572 } else if (bt_link_info
->a2dp_exist
) {
573 btc_alg_dbg(ALGO_TRACE
,
574 "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
575 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
576 } else if (bt_link_info
->pan_exist
) {
578 btc_alg_dbg(ALGO_TRACE
,
579 "[BTCoex], BT Profile = SCO + PAN(HS)\n");
580 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
582 btc_alg_dbg(ALGO_TRACE
,
583 "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
585 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
589 if (bt_link_info
->hid_exist
&&
590 bt_link_info
->a2dp_exist
) {
591 btc_alg_dbg(ALGO_TRACE
,
592 "[BTCoex], BT Profile = HID + A2DP\n");
593 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
594 } else if (bt_link_info
->hid_exist
&&
595 bt_link_info
->pan_exist
) {
597 btc_alg_dbg(ALGO_TRACE
,
598 "[BTCoex], BT Profile = HID + PAN(HS)\n");
600 BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
602 btc_alg_dbg(ALGO_TRACE
,
603 "[BTCoex], BT Profile = HID + PAN(EDR)\n");
605 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
607 } else if (bt_link_info
->pan_exist
&&
608 bt_link_info
->a2dp_exist
) {
610 btc_alg_dbg(ALGO_TRACE
,
611 "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
613 BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS
;
615 btc_alg_dbg(ALGO_TRACE
,
616 "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
618 BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP
;
622 } else if (numdiffprofile
== 3) {
623 if (bt_link_info
->sco_exist
) {
624 if (bt_link_info
->hid_exist
&&
625 bt_link_info
->a2dp_exist
) {
626 btc_alg_dbg(ALGO_TRACE
,
627 "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
628 algorithm
= BT_8723B_1ANT_COEX_ALGO_HID
;
629 } else if (bt_link_info
->hid_exist
&&
630 bt_link_info
->pan_exist
) {
632 btc_alg_dbg(ALGO_TRACE
,
633 "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
635 BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
637 btc_alg_dbg(ALGO_TRACE
,
638 "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
640 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
642 } else if (bt_link_info
->pan_exist
&&
643 bt_link_info
->a2dp_exist
) {
645 btc_alg_dbg(ALGO_TRACE
,
646 "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
647 algorithm
= BT_8723B_1ANT_COEX_ALGO_SCO
;
649 btc_alg_dbg(ALGO_TRACE
,
650 "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
652 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
656 if (bt_link_info
->hid_exist
&&
657 bt_link_info
->pan_exist
&&
658 bt_link_info
->a2dp_exist
) {
660 btc_alg_dbg(ALGO_TRACE
,
661 "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
663 BT_8723B_1ANT_COEX_ALGO_HID_A2DP
;
665 btc_alg_dbg(ALGO_TRACE
,
666 "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
668 BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR
;
672 } else if (numdiffprofile
>= 3) {
673 if (bt_link_info
->sco_exist
) {
674 if (bt_link_info
->hid_exist
&&
675 bt_link_info
->pan_exist
&&
676 bt_link_info
->a2dp_exist
) {
678 btc_alg_dbg(ALGO_TRACE
,
679 "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
681 btc_alg_dbg(ALGO_TRACE
,
682 "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
684 BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
;
693 static void btc8723b1ant_set_sw_pen_tx_rate_adapt(struct btc_coexist
*btcoexist
,
696 u8 h2c_parameter
[6] = {0};
698 h2c_parameter
[0] = 0x6; /* opCode, 0x6= Retry_Penalty */
700 if (low_penalty_ra
) {
701 h2c_parameter
[1] |= BIT0
;
702 /*normal rate except MCS7/6/5, OFDM54/48/36 */
703 h2c_parameter
[2] = 0x00;
704 h2c_parameter
[3] = 0xf7; /*MCS7 or OFDM54 */
705 h2c_parameter
[4] = 0xf8; /*MCS6 or OFDM48 */
706 h2c_parameter
[5] = 0xf9; /*MCS5 or OFDM36 */
709 btc_alg_dbg(ALGO_TRACE_FW_EXEC
,
710 "[BTCoex], set WiFi Low-Penalty Retry: %s",
711 (low_penalty_ra
? "ON!!" : "OFF!!"));
713 btcoexist
->btc_fill_h2c(btcoexist
, 0x69, 6, h2c_parameter
);
716 static void halbtc8723b1ant_low_penalty_ra(struct btc_coexist
*btcoexist
,
717 bool force_exec
, bool low_penalty_ra
)
719 coex_dm
->cur_low_penalty_ra
= low_penalty_ra
;
722 if (coex_dm
->pre_low_penalty_ra
== coex_dm
->cur_low_penalty_ra
)
725 btc8723b1ant_set_sw_pen_tx_rate_adapt(btcoexist
,
726 coex_dm
->cur_low_penalty_ra
);
728 coex_dm
->pre_low_penalty_ra
= coex_dm
->cur_low_penalty_ra
;
731 static void halbtc8723b1ant_set_coex_table(struct btc_coexist
*btcoexist
,
732 u32 val0x6c0
, u32 val0x6c4
,
733 u32 val0x6c8
, u8 val0x6cc
)
735 btc_alg_dbg(ALGO_TRACE_SW_EXEC
,
736 "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0
);
737 btcoexist
->btc_write_4byte(btcoexist
, 0x6c0, val0x6c0
);
739 btc_alg_dbg(ALGO_TRACE_SW_EXEC
,
740 "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4
);
741 btcoexist
->btc_write_4byte(btcoexist
, 0x6c4, val0x6c4
);
743 btc_alg_dbg(ALGO_TRACE_SW_EXEC
,
744 "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8
);
745 btcoexist
->btc_write_4byte(btcoexist
, 0x6c8, val0x6c8
);
747 btc_alg_dbg(ALGO_TRACE_SW_EXEC
,
748 "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc
);
749 btcoexist
->btc_write_1byte(btcoexist
, 0x6cc, val0x6cc
);
752 static void halbtc8723b1ant_coex_table(struct btc_coexist
*btcoexist
,
753 bool force_exec
, u32 val0x6c0
,
754 u32 val0x6c4
, u32 val0x6c8
,
757 btc_alg_dbg(ALGO_TRACE_SW
,
758 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6cc = 0x%x\n",
759 (force_exec
? "force to" : ""),
760 val0x6c0
, val0x6c4
, val0x6cc
);
761 coex_dm
->cur_val0x6c0
= val0x6c0
;
762 coex_dm
->cur_val0x6c4
= val0x6c4
;
763 coex_dm
->cur_val0x6c8
= val0x6c8
;
764 coex_dm
->cur_val0x6cc
= val0x6cc
;
767 if ((coex_dm
->pre_val0x6c0
== coex_dm
->cur_val0x6c0
) &&
768 (coex_dm
->pre_val0x6c4
== coex_dm
->cur_val0x6c4
) &&
769 (coex_dm
->pre_val0x6c8
== coex_dm
->cur_val0x6c8
) &&
770 (coex_dm
->pre_val0x6cc
== coex_dm
->cur_val0x6cc
))
773 halbtc8723b1ant_set_coex_table(btcoexist
, val0x6c0
, val0x6c4
,
776 coex_dm
->pre_val0x6c0
= coex_dm
->cur_val0x6c0
;
777 coex_dm
->pre_val0x6c4
= coex_dm
->cur_val0x6c4
;
778 coex_dm
->pre_val0x6c8
= coex_dm
->cur_val0x6c8
;
779 coex_dm
->pre_val0x6cc
= coex_dm
->cur_val0x6cc
;
782 static void halbtc8723b1ant_coex_table_with_type(struct btc_coexist
*btcoexist
,
783 bool force_exec
, u8 type
)
787 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
788 0x55555555, 0xffffff, 0x3);
791 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
792 0x5a5a5a5a, 0xffffff, 0x3);
795 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x5a5a5a5a,
796 0x5a5a5a5a, 0xffffff, 0x3);
799 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
800 0xaaaaaaaa, 0xffffff, 0x3);
803 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
804 0x5aaa5aaa, 0xffffff, 0x3);
807 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x5a5a5a5a,
808 0xaaaa5a5a, 0xffffff, 0x3);
811 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0x55555555,
812 0xaaaa5a5a, 0xffffff, 0x3);
815 halbtc8723b1ant_coex_table(btcoexist
, force_exec
, 0xaaaaaaaa,
816 0xaaaaaaaa, 0xffffff, 0x3);
823 static void halbtc8723b1ant_SetFwIgnoreWlanAct(struct btc_coexist
*btcoexist
,
826 u8 h2c_parameter
[1] = {0};
829 h2c_parameter
[0] |= BIT0
; /* function enable */
831 btc_alg_dbg(ALGO_TRACE_FW_EXEC
,
832 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
835 btcoexist
->btc_fill_h2c(btcoexist
, 0x63, 1, h2c_parameter
);
838 static void halbtc8723b1ant_ignore_wlan_act(struct btc_coexist
*btcoexist
,
839 bool force_exec
, bool enable
)
841 btc_alg_dbg(ALGO_TRACE_FW
,
842 "[BTCoex], %s turn Ignore WlanAct %s\n",
843 (force_exec
? "force to" : ""), (enable
? "ON" : "OFF"));
844 coex_dm
->cur_ignore_wlan_act
= enable
;
847 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
848 "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
849 coex_dm
->pre_ignore_wlan_act
,
850 coex_dm
->cur_ignore_wlan_act
);
852 if (coex_dm
->pre_ignore_wlan_act
==
853 coex_dm
->cur_ignore_wlan_act
)
856 halbtc8723b1ant_SetFwIgnoreWlanAct(btcoexist
, enable
);
858 coex_dm
->pre_ignore_wlan_act
= coex_dm
->cur_ignore_wlan_act
;
861 static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist
*btcoexist
,
862 u8 byte1
, u8 byte2
, u8 byte3
,
865 u8 h2c_parameter
[5] = {0};
866 u8 real_byte1
= byte1
, real_byte5
= byte5
;
867 bool ap_enable
= false;
869 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_AP_MODE_ENABLE
,
873 if ((byte1
& BIT4
) && !(byte1
& BIT5
)) {
874 btc_iface_dbg(INTF_NOTIFY
,
875 "[BTCoex], FW for 1Ant AP mode\n");
884 h2c_parameter
[0] = real_byte1
;
885 h2c_parameter
[1] = byte2
;
886 h2c_parameter
[2] = byte3
;
887 h2c_parameter
[3] = byte4
;
888 h2c_parameter
[4] = real_byte5
;
890 coex_dm
->ps_tdma_para
[0] = real_byte1
;
891 coex_dm
->ps_tdma_para
[1] = byte2
;
892 coex_dm
->ps_tdma_para
[2] = byte3
;
893 coex_dm
->ps_tdma_para
[3] = byte4
;
894 coex_dm
->ps_tdma_para
[4] = real_byte5
;
896 btc_alg_dbg(ALGO_TRACE_FW_EXEC
,
897 "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
899 h2c_parameter
[1] << 24 |
900 h2c_parameter
[2] << 16 |
901 h2c_parameter
[3] << 8 |
904 btcoexist
->btc_fill_h2c(btcoexist
, 0x60, 5, h2c_parameter
);
907 static void halbtc8723b1ant_set_lps_rpwm(struct btc_coexist
*btcoexist
,
908 u8 lps_val
, u8 rpwm_val
)
913 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_LPS_VAL
, &lps
);
914 btcoexist
->btc_set(btcoexist
, BTC_SET_U1_RPWM_VAL
, &rpwm
);
917 static void halbtc8723b1ant_LpsRpwm(struct btc_coexist
*btcoexist
,
919 u8 lps_val
, u8 rpwm_val
)
921 btc_alg_dbg(ALGO_TRACE_FW
,
922 "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
923 (force_exec
? "force to" : ""), lps_val
, rpwm_val
);
924 coex_dm
->cur_lps
= lps_val
;
925 coex_dm
->cur_rpwm
= rpwm_val
;
928 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
929 "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n",
930 coex_dm
->cur_lps
, coex_dm
->cur_rpwm
);
932 if ((coex_dm
->pre_lps
== coex_dm
->cur_lps
) &&
933 (coex_dm
->pre_rpwm
== coex_dm
->cur_rpwm
)) {
934 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
935 "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n",
936 coex_dm
->pre_rpwm
, coex_dm
->cur_rpwm
);
941 halbtc8723b1ant_set_lps_rpwm(btcoexist
, lps_val
, rpwm_val
);
943 coex_dm
->pre_lps
= coex_dm
->cur_lps
;
944 coex_dm
->pre_rpwm
= coex_dm
->cur_rpwm
;
947 static void halbtc8723b1ant_sw_mechanism(struct btc_coexist
*btcoexist
,
950 btc_alg_dbg(ALGO_BT_MONITOR
,
951 "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra
);
953 halbtc8723b1ant_low_penalty_ra(btcoexist
, NORMAL_EXEC
, low_penalty_ra
);
956 static void halbtc8723b1ant_SetAntPath(struct btc_coexist
*btcoexist
,
957 u8 ant_pos_type
, bool init_hw_cfg
,
960 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
961 u32 fw_ver
= 0, u32tmp
= 0;
962 bool pg_ext_switch
= false;
963 bool use_ext_switch
= false;
964 u8 h2c_parameter
[2] = {0};
966 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_EXT_SWITCH
, &pg_ext_switch
);
967 /* [31:16] = fw ver, [15:0] = fw sub ver */
968 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
970 if ((fw_ver
< 0xc0000) || pg_ext_switch
)
971 use_ext_switch
= true;
974 /*BT select s0/s1 is controlled by WiFi */
975 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x67, 0x20, 0x1);
977 /*Force GNT_BT to Normal */
978 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x765, 0x18, 0x0);
979 } else if (wifi_off
) {
980 /*Force GNT_BT to High */
981 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x765, 0x18, 0x3);
982 /*BT select s0/s1 is controlled by BT */
983 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x67, 0x20, 0x0);
985 /* 0x4c[24:23] = 00, Set Antenna control by BT_RFE_CTRL
986 * BT Vendor 0xac = 0xf002
988 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
991 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u32tmp
);
994 if (use_ext_switch
) {
996 /* 0x4c[23] = 0, 0x4c[24] = 1
997 * Antenna control by WL/BT
999 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
1002 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u32tmp
);
1004 if (board_info
->btdm_ant_pos
==
1005 BTC_ANTENNA_AT_MAIN_PORT
) {
1006 /* Main Ant to BT for IPS case 0x4c[23] = 1 */
1007 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1011 /*tell firmware "no antenna inverse"*/
1012 h2c_parameter
[0] = 0;
1013 h2c_parameter
[1] = 1; /*ext switch type*/
1014 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1017 /*Aux Ant to BT for IPS case 0x4c[23] = 1 */
1018 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1022 /*tell firmware "antenna inverse"*/
1023 h2c_parameter
[0] = 1;
1024 h2c_parameter
[1] = 1; /*ext switch type*/
1025 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1030 /* fixed internal switch first*/
1031 /* fixed internal switch S1->WiFi, S0->BT*/
1032 if (board_info
->btdm_ant_pos
== BTC_ANTENNA_AT_MAIN_PORT
)
1033 btcoexist
->btc_write_2byte(btcoexist
, 0x948, 0x0);
1034 else/* fixed internal switch S0->WiFi, S1->BT*/
1035 btcoexist
->btc_write_2byte(btcoexist
, 0x948, 0x280);
1037 /* ext switch setting */
1038 switch (ant_pos_type
) {
1039 case BTC_ANT_PATH_WIFI
:
1040 if (board_info
->btdm_ant_pos
==
1041 BTC_ANTENNA_AT_MAIN_PORT
)
1042 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1046 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1050 case BTC_ANT_PATH_BT
:
1051 if (board_info
->btdm_ant_pos
==
1052 BTC_ANTENNA_AT_MAIN_PORT
)
1053 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1057 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1062 case BTC_ANT_PATH_PTA
:
1063 if (board_info
->btdm_ant_pos
==
1064 BTC_ANTENNA_AT_MAIN_PORT
)
1065 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1069 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1077 /* 0x4c[23] = 1, 0x4c[24] = 0 Antenna control by 0x64*/
1078 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
1081 btcoexist
->btc_write_4byte(btcoexist
, 0x4c, u32tmp
);
1083 if (board_info
->btdm_ant_pos
==
1084 BTC_ANTENNA_AT_MAIN_PORT
) {
1085 /*Main Ant to WiFi for IPS case 0x4c[23] = 1*/
1086 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1090 /*tell firmware "no antenna inverse"*/
1091 h2c_parameter
[0] = 0;
1092 h2c_parameter
[1] = 0; /*internal switch type*/
1093 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1096 /*Aux Ant to BT for IPS case 0x4c[23] = 1*/
1097 btcoexist
->btc_write_1byte_bitmask(btcoexist
,
1101 /*tell firmware "antenna inverse"*/
1102 h2c_parameter
[0] = 1;
1103 h2c_parameter
[1] = 0; /*internal switch type*/
1104 btcoexist
->btc_fill_h2c(btcoexist
, 0x65, 2,
1109 /* fixed external switch first*/
1110 /*Main->WiFi, Aux->BT*/
1111 if (board_info
->btdm_ant_pos
==
1112 BTC_ANTENNA_AT_MAIN_PORT
)
1113 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x92c,
1115 else/*Main->BT, Aux->WiFi */
1116 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x92c,
1119 /* internal switch setting*/
1120 switch (ant_pos_type
) {
1121 case BTC_ANT_PATH_WIFI
:
1122 if (board_info
->btdm_ant_pos
==
1123 BTC_ANTENNA_AT_MAIN_PORT
)
1124 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1127 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1130 case BTC_ANT_PATH_BT
:
1131 if (board_info
->btdm_ant_pos
==
1132 BTC_ANTENNA_AT_MAIN_PORT
)
1133 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1136 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1140 case BTC_ANT_PATH_PTA
:
1141 if (board_info
->btdm_ant_pos
==
1142 BTC_ANTENNA_AT_MAIN_PORT
)
1143 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1146 btcoexist
->btc_write_2byte(btcoexist
, 0x948,
1153 static void halbtc8723b1ant_ps_tdma(struct btc_coexist
*btcoexist
,
1154 bool force_exec
, bool turn_on
, u8 type
)
1156 bool wifi_busy
= false;
1157 u8 rssi_adjust_val
= 0;
1159 coex_dm
->cur_ps_tdma_on
= turn_on
;
1160 coex_dm
->cur_ps_tdma
= type
;
1162 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
1165 if (coex_dm
->cur_ps_tdma_on
)
1166 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1167 "[BTCoex], ******** TDMA(on, %d) *********\n",
1168 coex_dm
->cur_ps_tdma
);
1170 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1171 "[BTCoex], ******** TDMA(off, %d) ********\n",
1172 coex_dm
->cur_ps_tdma
);
1174 if ((coex_dm
->pre_ps_tdma_on
== coex_dm
->cur_ps_tdma_on
) &&
1175 (coex_dm
->pre_ps_tdma
== coex_dm
->cur_ps_tdma
))
1181 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x1a,
1185 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x3a,
1188 rssi_adjust_val
= 11;
1191 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x2b,
1193 rssi_adjust_val
= 14;
1196 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x1d,
1200 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x15,
1202 rssi_adjust_val
= 17;
1205 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x15,
1209 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x20,
1213 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x13, 0xc,
1217 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x25,
1221 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x21,
1223 rssi_adjust_val
= 18;
1226 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x13, 0xa,
1230 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x15,
1232 rssi_adjust_val
= 20;
1235 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x0a,
1239 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x15,
1243 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x21,
1247 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x13, 0xa,
1251 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x15,
1253 rssi_adjust_val
= 18;
1256 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x93, 0x25,
1258 rssi_adjust_val
= 14;
1261 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x35,
1265 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x25,
1269 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0x25,
1273 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0x25,
1275 rssi_adjust_val
= 22;
1278 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0x15,
1280 rssi_adjust_val
= 22;
1283 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0xa,
1285 rssi_adjust_val
= 22;
1288 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0xa,
1290 rssi_adjust_val
= 22;
1293 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xe3, 0x25,
1295 rssi_adjust_val
= 22;
1298 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x69, 0x25,
1302 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xab, 0x1a,
1306 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x51, 0x14,
1310 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xd3, 0x1a,
1314 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x61, 0xa,
1318 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xa3, 0x25,
1322 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x53, 0x1a,
1326 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x63, 0x1a,
1330 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0xd3, 0x12,
1333 /* SoftAP only with no sta associated,BT disable ,
1334 * TDMA mode for power saving
1335 * here softap mode screen off will cost 70-80mA for phone
1338 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x23, 0x18,
1344 case 8: /*PTA Control */
1345 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x8, 0x0,
1347 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_PTA
,
1351 default: /*Software control, Antenna at BT side */
1352 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x0, 0x0,
1354 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
,
1357 case 9: /*Software control, Antenna at WiFi side */
1358 halbtc8723b1ant_set_fw_ps_tdma(btcoexist
, 0x0, 0x0,
1360 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_WIFI
,
1365 rssi_adjust_val
= 0;
1366 btcoexist
->btc_set(btcoexist
,
1367 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE
,
1370 /* update pre state */
1371 coex_dm
->pre_ps_tdma_on
= coex_dm
->cur_ps_tdma_on
;
1372 coex_dm
->pre_ps_tdma
= coex_dm
->cur_ps_tdma
;
1375 static bool halbtc8723b1ant_is_common_action(struct btc_coexist
*btcoexist
)
1377 bool commom
= false, wifi_connected
= false;
1378 bool wifi_busy
= false;
1380 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
1382 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
1384 if (!wifi_connected
&&
1385 BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
== coex_dm
->bt_status
) {
1386 btc_alg_dbg(ALGO_TRACE
,
1387 "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
1388 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1390 } else if (wifi_connected
&&
1391 (BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
==
1392 coex_dm
->bt_status
)) {
1393 btc_alg_dbg(ALGO_TRACE
,
1394 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1395 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1397 } else if (!wifi_connected
&&
1398 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
==
1399 coex_dm
->bt_status
)) {
1400 btc_alg_dbg(ALGO_TRACE
,
1401 "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
1402 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1404 } else if (wifi_connected
&&
1405 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
==
1406 coex_dm
->bt_status
)) {
1407 btc_alg_dbg(ALGO_TRACE
,
1408 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1409 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1411 } else if (!wifi_connected
&&
1412 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
!=
1413 coex_dm
->bt_status
)) {
1414 btc_alg_dbg(ALGO_TRACE
,
1415 "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
1416 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1420 btc_alg_dbg(ALGO_TRACE
,
1421 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1423 btc_alg_dbg(ALGO_TRACE
,
1424 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1432 static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist
*btcoexist
,
1435 static s32 up
, dn
, m
, n
, wait_count
;
1436 /* 0: no change, +1: increase WiFi duration,
1437 * -1: decrease WiFi duration
1440 u8 retry_count
= 0, bt_info_ext
;
1441 bool wifi_busy
= false;
1443 btc_alg_dbg(ALGO_TRACE_FW
,
1444 "[BTCoex], TdmaDurationAdjustForAcl()\n");
1446 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
== wifi_status
)
1451 if ((BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN
==
1453 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
== wifi_status
) ||
1454 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT
== wifi_status
)) {
1455 if (coex_dm
->cur_ps_tdma
!= 1 && coex_dm
->cur_ps_tdma
!= 2 &&
1456 coex_dm
->cur_ps_tdma
!= 3 && coex_dm
->cur_ps_tdma
!= 9) {
1457 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1459 coex_dm
->tdma_adj_type
= 9;
1471 if (!coex_dm
->auto_tdma_adjust
) {
1472 coex_dm
->auto_tdma_adjust
= true;
1473 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1474 "[BTCoex], first run TdmaDurationAdjust()!!\n");
1476 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 2);
1477 coex_dm
->tdma_adj_type
= 2;
1486 /*accquire the BT TRx retry count from BT_Info byte2 */
1487 retry_count
= coex_sta
->bt_retry_cnt
;
1488 bt_info_ext
= coex_sta
->bt_info_ext
;
1491 /* no retry in the last 2-second duration */
1492 if (retry_count
== 0) {
1505 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1506 "[BTCoex], Increase wifi duration!!\n");
1508 } else if (retry_count
<= 3) {
1516 if (wait_count
<= 2)
1529 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1530 "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
1533 if (wait_count
== 1)
1546 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1547 "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
1551 if ((BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext
)) &&
1552 ((coex_dm
->cur_ps_tdma
== 1) ||
1553 (coex_dm
->cur_ps_tdma
== 2))) {
1554 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1556 coex_dm
->tdma_adj_type
= 9;
1557 } else if (coex_dm
->cur_ps_tdma
== 1) {
1558 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1560 coex_dm
->tdma_adj_type
= 2;
1561 } else if (coex_dm
->cur_ps_tdma
== 2) {
1562 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1564 coex_dm
->tdma_adj_type
= 9;
1565 } else if (coex_dm
->cur_ps_tdma
== 9) {
1566 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1568 coex_dm
->tdma_adj_type
= 11;
1570 } else if (result
== 1) {
1571 if ((BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext
)) &&
1572 ((coex_dm
->cur_ps_tdma
== 1) ||
1573 (coex_dm
->cur_ps_tdma
== 2))) {
1574 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1576 coex_dm
->tdma_adj_type
= 9;
1577 } else if (coex_dm
->cur_ps_tdma
== 11) {
1578 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1580 coex_dm
->tdma_adj_type
= 9;
1581 } else if (coex_dm
->cur_ps_tdma
== 9) {
1582 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1584 coex_dm
->tdma_adj_type
= 2;
1585 } else if (coex_dm
->cur_ps_tdma
== 2) {
1586 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1588 coex_dm
->tdma_adj_type
= 1;
1590 } else { /*no change */
1591 /*if busy / idle change */
1592 btc_alg_dbg(ALGO_TRACE_FW_DETAIL
,
1593 "[BTCoex],********* TDMA(on, %d) ********\n",
1594 coex_dm
->cur_ps_tdma
);
1597 if (coex_dm
->cur_ps_tdma
!= 1 && coex_dm
->cur_ps_tdma
!= 2 &&
1598 coex_dm
->cur_ps_tdma
!= 9 && coex_dm
->cur_ps_tdma
!= 11) {
1599 /* recover to previous adjust type */
1600 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true,
1601 coex_dm
->tdma_adj_type
);
1606 static void btc8723b1ant_pstdmachkpwrsave(struct btc_coexist
*btcoexist
,
1611 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_LPS_MODE
, &lps_mode
);
1613 if (lps_mode
) { /* already under LPS state */
1615 /* keep state under LPS, do nothing. */
1617 /* will leave LPS state, turn off psTdma first */
1618 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1621 } else { /* NO PS state */
1623 /* will enter LPS state, turn off psTdma first */
1624 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1627 /* keep state under NO PS state, do nothing. */
1632 static void halbtc8723b1ant_power_save_state(struct btc_coexist
*btcoexist
,
1633 u8 ps_type
, u8 lps_val
,
1636 bool low_pwr_disable
= false;
1639 case BTC_PS_WIFI_NATIVE
:
1640 /* recover to original 32k low power setting */
1641 low_pwr_disable
= false;
1642 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_DISABLE_LOW_POWER
,
1644 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_NORMAL_LPS
, NULL
);
1647 btc8723b1ant_pstdmachkpwrsave(btcoexist
, true);
1648 halbtc8723b1ant_LpsRpwm(btcoexist
, NORMAL_EXEC
, lps_val
,
1650 /* when coex force to enter LPS, do not enter 32k low power. */
1651 low_pwr_disable
= true;
1652 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_DISABLE_LOW_POWER
,
1654 /* power save must executed before psTdma. */
1655 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_ENTER_LPS
, NULL
);
1657 case BTC_PS_LPS_OFF
:
1658 btc8723b1ant_pstdmachkpwrsave(btcoexist
, false);
1659 btcoexist
->btc_set(btcoexist
, BTC_SET_ACT_LEAVE_LPS
, NULL
);
1666 /***************************************************
1668 * Software Coex Mechanism start
1670 ***************************************************/
1671 /* SCO only or SCO+PAN(HS) */
1672 static void halbtc8723b1ant_action_sco(struct btc_coexist
*btcoexist
)
1674 halbtc8723b1ant_sw_mechanism(btcoexist
, true);
1677 static void halbtc8723b1ant_action_hid(struct btc_coexist
*btcoexist
)
1679 halbtc8723b1ant_sw_mechanism(btcoexist
, true);
1682 /*A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
1683 static void halbtc8723b1ant_action_a2dp(struct btc_coexist
*btcoexist
)
1685 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1688 static void halbtc8723b1ant_action_a2dp_pan_hs(struct btc_coexist
*btcoexist
)
1690 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1693 static void halbtc8723b1ant_action_pan_edr(struct btc_coexist
*btcoexist
)
1695 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1699 static void halbtc8723b1ant_action_pan_hs(struct btc_coexist
*btcoexist
)
1701 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1705 static void halbtc8723b1ant_action_pan_edr_a2dp(struct btc_coexist
*btcoexist
)
1707 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
1710 static void halbtc8723b1ant_action_pan_edr_hid(struct btc_coexist
*btcoexist
)
1712 halbtc8723b1ant_sw_mechanism(btcoexist
, true);
1715 /* HID+A2DP+PAN(EDR) */
1716 static void btc8723b1ant_action_hid_a2dp_pan_edr(struct btc_coexist
*btcoexist
)
1718 halbtc8723b1ant_sw_mechanism(btcoexist
, true);
1721 static void halbtc8723b1ant_action_hid_a2dp(struct btc_coexist
*btcoexist
)
1723 halbtc8723b1ant_sw_mechanism(btcoexist
, true);
1726 /*****************************************************
1728 * Non-Software Coex Mechanism start
1730 *****************************************************/
1731 static void halbtc8723b1ant_action_wifi_multiport(struct btc_coexist
*btcoexist
)
1733 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
1736 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
1737 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
1740 static void halbtc8723b1ant_action_hs(struct btc_coexist
*btcoexist
)
1742 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
1743 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
1746 static void halbtc8723b1ant_action_bt_inquiry(struct btc_coexist
*btcoexist
)
1748 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1749 bool wifi_connected
= false, ap_enable
= false;
1751 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_AP_MODE_ENABLE
,
1753 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
1756 if (!wifi_connected
) {
1757 halbtc8723b1ant_power_save_state(btcoexist
,
1758 BTC_PS_WIFI_NATIVE
, 0x0, 0x0);
1759 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
1760 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
1761 } else if (bt_link_info
->sco_exist
|| bt_link_info
->hid_only
) {
1762 /* SCO/HID-only busy */
1763 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
1765 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 32);
1766 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1769 halbtc8723b1ant_power_save_state(btcoexist
,
1773 halbtc8723b1ant_power_save_state(btcoexist
,
1777 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 30);
1778 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1782 static void btc8723b1ant_act_bt_sco_hid_only_busy(struct btc_coexist
*btcoexist
,
1785 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1786 bool wifi_connected
= false;
1788 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
1791 /* tdma and coex table */
1793 if (bt_link_info
->sco_exist
) {
1794 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 5);
1795 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
1797 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 6);
1798 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 5);
1802 static void halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
1803 struct btc_coexist
*btcoexist
,
1808 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1810 bt_rssi_state
= halbtc8723b1ant_bt_rssi_state(2, 28, 0);
1812 if (bt_link_info
->hid_only
) { /*HID */
1813 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist
, wifi_status
);
1814 coex_dm
->auto_tdma_adjust
= false;
1816 } else if (bt_link_info
->a2dp_only
) { /*A2DP */
1817 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
== wifi_status
) {
1818 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1820 halbtc8723b1ant_coex_table_with_type(btcoexist
,
1822 coex_dm
->auto_tdma_adjust
= false;
1823 } else if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
1824 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
1825 btc8723b1ant_tdma_dur_adj_for_acl(btcoexist
,
1827 halbtc8723b1ant_coex_table_with_type(btcoexist
,
1829 } else { /*for low BT RSSI */
1830 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1832 halbtc8723b1ant_coex_table_with_type(btcoexist
,
1834 coex_dm
->auto_tdma_adjust
= false;
1836 } else if (bt_link_info
->hid_exist
&&
1837 bt_link_info
->a2dp_exist
) { /*HID+A2DP */
1838 if ((bt_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
1839 (bt_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
1840 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1842 coex_dm
->auto_tdma_adjust
= false;
1843 } else { /*for low BT RSSI*/
1844 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1846 coex_dm
->auto_tdma_adjust
= false;
1849 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 6);
1850 /*PAN(OPP,FTP), HID+PAN(OPP,FTP) */
1851 } else if (bt_link_info
->pan_only
||
1852 (bt_link_info
->hid_exist
&& bt_link_info
->pan_exist
)) {
1853 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 3);
1854 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 6);
1855 coex_dm
->auto_tdma_adjust
= false;
1856 /*A2DP+PAN(OPP,FTP), HID+A2DP+PAN(OPP,FTP)*/
1857 } else if ((bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) ||
1858 (bt_link_info
->hid_exist
&& bt_link_info
->a2dp_exist
&&
1859 bt_link_info
->pan_exist
)) {
1860 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 13);
1861 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1862 coex_dm
->auto_tdma_adjust
= false;
1864 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 11);
1865 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1866 coex_dm
->auto_tdma_adjust
= false;
1870 static void btc8723b1ant_action_wifi_not_conn(struct btc_coexist
*btcoexist
)
1872 /* power save state */
1873 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
1876 /* tdma and coex table */
1877 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
1878 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 0);
1881 static void btc8723b1ant_action_wifi_not_conn_scan(struct btc_coexist
*btcoex
)
1883 struct btc_bt_link_info
*bt_link_info
= &btcoex
->bt_link_info
;
1885 halbtc8723b1ant_power_save_state(btcoex
, BTC_PS_WIFI_NATIVE
,
1888 /* tdma and coex table */
1889 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
1890 if (bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) {
1891 halbtc8723b1ant_ps_tdma(btcoex
, NORMAL_EXEC
,
1893 halbtc8723b1ant_coex_table_with_type(btcoex
,
1895 } else if (bt_link_info
->pan_only
) {
1896 halbtc8723b1ant_ps_tdma(btcoex
, NORMAL_EXEC
,
1898 halbtc8723b1ant_coex_table_with_type(btcoex
,
1901 halbtc8723b1ant_ps_tdma(btcoex
, NORMAL_EXEC
,
1903 halbtc8723b1ant_coex_table_with_type(btcoex
,
1906 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
1907 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
1908 coex_dm
->bt_status
)){
1909 btc8723b1ant_act_bt_sco_hid_only_busy(btcoex
,
1910 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
);
1912 halbtc8723b1ant_ps_tdma(btcoex
, NORMAL_EXEC
, false, 8);
1913 halbtc8723b1ant_coex_table_with_type(btcoex
, NORMAL_EXEC
, 2);
1917 static void btc8723b1ant_act_wifi_not_conn_asso_auth(struct btc_coexist
*btcoex
)
1919 struct btc_bt_link_info
*bt_link_info
= &btcoex
->bt_link_info
;
1921 halbtc8723b1ant_power_save_state(btcoex
, BTC_PS_WIFI_NATIVE
,
1924 if ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
== coex_dm
->bt_status
) ||
1925 (bt_link_info
->sco_exist
) || (bt_link_info
->hid_only
) ||
1926 (bt_link_info
->a2dp_only
) || (bt_link_info
->pan_only
)) {
1927 halbtc8723b1ant_ps_tdma(btcoex
, NORMAL_EXEC
, false, 8);
1928 halbtc8723b1ant_coex_table_with_type(btcoex
, NORMAL_EXEC
, 7);
1930 halbtc8723b1ant_ps_tdma(btcoex
, NORMAL_EXEC
, true, 20);
1931 halbtc8723b1ant_coex_table_with_type(btcoex
, NORMAL_EXEC
, 1);
1935 static void btc8723b1ant_action_wifi_conn_scan(struct btc_coexist
*btcoexist
)
1937 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1939 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
1942 /* tdma and coex table */
1943 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
1944 if (bt_link_info
->a2dp_exist
&& bt_link_info
->pan_exist
) {
1945 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1947 halbtc8723b1ant_coex_table_with_type(btcoexist
,
1949 } else if (bt_link_info
->pan_only
) {
1950 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1952 halbtc8723b1ant_coex_table_with_type(btcoexist
,
1955 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
1957 halbtc8723b1ant_coex_table_with_type(btcoexist
,
1960 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
1961 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
1962 coex_dm
->bt_status
)) {
1963 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist
,
1964 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
);
1966 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
1967 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
1971 static void halbtc8723b1ant_action_wifi_connected_special_packet(
1972 struct btc_coexist
*btcoexist
)
1974 bool hs_connecting
= false;
1975 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
1977 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_CONNECTING
, &hs_connecting
);
1979 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
1982 /* tdma and coex table */
1983 if ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
== coex_dm
->bt_status
) ||
1984 (bt_link_info
->sco_exist
) || (bt_link_info
->hid_only
) ||
1985 (bt_link_info
->a2dp_only
) || (bt_link_info
->pan_only
)) {
1986 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 8);
1987 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 7);
1989 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, true, 20);
1990 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 1);
1994 static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist
*btcoexist
)
1996 bool wifi_busy
= false;
1997 bool scan
= false, link
= false, roam
= false;
1998 bool under_4way
= false, ap_enable
= false;
2000 btc_alg_dbg(ALGO_TRACE
,
2001 "[BTCoex], CoexForWifiConnect()===>\n");
2003 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_4_WAY_PROGRESS
,
2006 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist
);
2007 btc_alg_dbg(ALGO_TRACE
,
2008 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
2012 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
2013 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
2014 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
2016 if (scan
|| link
|| roam
) {
2018 btc8723b1ant_action_wifi_conn_scan(btcoexist
);
2020 halbtc8723b1ant_action_wifi_connected_special_packet(
2022 btc_alg_dbg(ALGO_TRACE
,
2023 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
2027 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_AP_MODE_ENABLE
,
2029 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
2030 /* power save state */
2032 BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
&&
2033 !btcoexist
->bt_link_info
.hid_only
) {
2034 if (!wifi_busy
&& btcoexist
->bt_link_info
.a2dp_only
)
2035 halbtc8723b1ant_power_save_state(btcoexist
,
2039 halbtc8723b1ant_power_save_state(btcoexist
,
2043 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
2046 /* tdma and coex table */
2048 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
2049 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(btcoexist
,
2050 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
2051 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
==
2052 coex_dm
->bt_status
) ||
2053 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
2054 coex_dm
->bt_status
)) {
2055 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist
,
2056 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
2058 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2060 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2064 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) {
2065 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(btcoexist
,
2066 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
2067 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY
==
2068 coex_dm
->bt_status
) ||
2069 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
==
2070 coex_dm
->bt_status
)) {
2071 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist
,
2072 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
2074 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
,
2076 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2082 static void btc8723b1ant_run_sw_coex_mech(struct btc_coexist
*btcoexist
)
2086 algorithm
= halbtc8723b1ant_action_algorithm(btcoexist
);
2087 coex_dm
->cur_algorithm
= algorithm
;
2089 if (!halbtc8723b1ant_is_common_action(btcoexist
)) {
2090 switch (coex_dm
->cur_algorithm
) {
2091 case BT_8723B_1ANT_COEX_ALGO_SCO
:
2092 btc_alg_dbg(ALGO_TRACE
,
2093 "[BTCoex], Action algorithm = SCO\n");
2094 halbtc8723b1ant_action_sco(btcoexist
);
2096 case BT_8723B_1ANT_COEX_ALGO_HID
:
2097 btc_alg_dbg(ALGO_TRACE
,
2098 "[BTCoex], Action algorithm = HID\n");
2099 halbtc8723b1ant_action_hid(btcoexist
);
2101 case BT_8723B_1ANT_COEX_ALGO_A2DP
:
2102 btc_alg_dbg(ALGO_TRACE
,
2103 "[BTCoex], Action algorithm = A2DP\n");
2104 halbtc8723b1ant_action_a2dp(btcoexist
);
2106 case BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS
:
2107 btc_alg_dbg(ALGO_TRACE
,
2108 "[BTCoex], Action algorithm = A2DP+PAN(HS)\n");
2109 halbtc8723b1ant_action_a2dp_pan_hs(btcoexist
);
2111 case BT_8723B_1ANT_COEX_ALGO_PANEDR
:
2112 btc_alg_dbg(ALGO_TRACE
,
2113 "[BTCoex], Action algorithm = PAN(EDR)\n");
2114 halbtc8723b1ant_action_pan_edr(btcoexist
);
2116 case BT_8723B_1ANT_COEX_ALGO_PANHS
:
2117 btc_alg_dbg(ALGO_TRACE
,
2118 "[BTCoex], Action algorithm = HS mode\n");
2119 halbtc8723b1ant_action_pan_hs(btcoexist
);
2121 case BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP
:
2122 btc_alg_dbg(ALGO_TRACE
,
2123 "[BTCoex], Action algorithm = PAN+A2DP\n");
2124 halbtc8723b1ant_action_pan_edr_a2dp(btcoexist
);
2126 case BT_8723B_1ANT_COEX_ALGO_PANEDR_HID
:
2127 btc_alg_dbg(ALGO_TRACE
,
2128 "[BTCoex], Action algorithm = PAN(EDR)+HID\n");
2129 halbtc8723b1ant_action_pan_edr_hid(btcoexist
);
2131 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR
:
2132 btc_alg_dbg(ALGO_TRACE
,
2133 "[BTCoex], Action algorithm = HID+A2DP+PAN\n");
2134 btc8723b1ant_action_hid_a2dp_pan_edr(btcoexist
);
2136 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP
:
2137 btc_alg_dbg(ALGO_TRACE
,
2138 "[BTCoex], Action algorithm = HID+A2DP\n");
2139 halbtc8723b1ant_action_hid_a2dp(btcoexist
);
2142 btc_alg_dbg(ALGO_TRACE
,
2143 "[BTCoex], Action algorithm = coexist All Off!!\n");
2146 coex_dm
->pre_algorithm
= coex_dm
->cur_algorithm
;
2150 static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist
*btcoexist
)
2152 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2153 bool wifi_connected
= false, bt_hs_on
= false;
2154 bool increase_scan_dev_num
= false;
2155 bool bt_ctrl_agg_buf_size
= false;
2156 u8 agg_buf_size
= 5;
2157 u8 wifi_rssi_state
= BTC_RSSI_STATE_HIGH
;
2158 u32 wifi_link_status
= 0;
2159 u32 num_of_wifi_link
= 0;
2161 btc_alg_dbg(ALGO_TRACE
,
2162 "[BTCoex], RunCoexistMechanism()===>\n");
2164 if (btcoexist
->manual_control
) {
2165 btc_alg_dbg(ALGO_TRACE
,
2166 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
2170 if (btcoexist
->stop_coex_dm
) {
2171 btc_alg_dbg(ALGO_TRACE
,
2172 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
2176 if (coex_sta
->under_ips
) {
2177 btc_alg_dbg(ALGO_TRACE
,
2178 "[BTCoex], wifi is under IPS !!!\n");
2182 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) ||
2183 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
2184 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
)) {
2185 increase_scan_dev_num
= true;
2188 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_INC_SCAN_DEV_NUM
,
2189 &increase_scan_dev_num
);
2191 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2194 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_LINK_STATUS
,
2196 num_of_wifi_link
= wifi_link_status
>> 16;
2197 if (num_of_wifi_link
>= 2) {
2198 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
2199 halbtc8723b1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
2200 bt_ctrl_agg_buf_size
,
2202 halbtc8723b1ant_action_wifi_multiport(btcoexist
);
2206 if (!bt_link_info
->sco_exist
&& !bt_link_info
->hid_exist
) {
2207 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
2209 if (wifi_connected
) {
2211 halbtc8723b1ant_wifi_rssi_state(btcoexist
,
2213 if ((wifi_rssi_state
== BTC_RSSI_STATE_HIGH
) ||
2214 (wifi_rssi_state
== BTC_RSSI_STATE_STAY_HIGH
)) {
2215 halbtc8723b1ant_limited_tx(btcoexist
,
2219 halbtc8723b1ant_limited_tx(btcoexist
,
2224 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
,
2229 if (bt_link_info
->sco_exist
) {
2230 bt_ctrl_agg_buf_size
= true;
2232 } else if (bt_link_info
->hid_exist
) {
2233 bt_ctrl_agg_buf_size
= true;
2235 } else if (bt_link_info
->a2dp_exist
|| bt_link_info
->pan_exist
) {
2236 bt_ctrl_agg_buf_size
= true;
2239 halbtc8723b1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
2240 bt_ctrl_agg_buf_size
, agg_buf_size
);
2242 btc8723b1ant_run_sw_coex_mech(btcoexist
);
2244 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2246 if (coex_sta
->c2h_bt_inquiry_page
) {
2247 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
2249 } else if (bt_hs_on
) {
2250 halbtc8723b1ant_action_hs(btcoexist
);
2254 if (!wifi_connected
) {
2255 bool scan
= false, link
= false, roam
= false;
2257 btc_alg_dbg(ALGO_TRACE
,
2258 "[BTCoex], wifi is non connected-idle !!!\n");
2260 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
2261 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
2262 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
2264 if (scan
|| link
|| roam
) {
2266 btc8723b1ant_action_wifi_not_conn_scan(
2269 btc8723b1ant_act_wifi_not_conn_asso_auth(
2272 btc8723b1ant_action_wifi_not_conn(btcoexist
);
2274 } else { /* wifi LPS/Busy */
2275 halbtc8723b1ant_action_wifi_connected(btcoexist
);
2279 static void halbtc8723b1ant_init_coex_dm(struct btc_coexist
*btcoexist
)
2282 halbtc8723b1ant_sw_mechanism(btcoexist
, false);
2284 halbtc8723b1ant_ps_tdma(btcoexist
, FORCE_EXEC
, false, 8);
2285 halbtc8723b1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 0);
2288 static void halbtc8723b1ant_init_hw_config(struct btc_coexist
*btcoexist
,
2293 u32 cnt_bt_cal_chk
= 0;
2295 btc_iface_dbg(INTF_INIT
,
2296 "[BTCoex], 1Ant Init HW Config!!\n");
2298 if (backup
) {/* backup rf 0x1e value */
2299 coex_dm
->backup_arfr_cnt1
=
2300 btcoexist
->btc_read_4byte(btcoexist
, 0x430);
2301 coex_dm
->backup_arfr_cnt2
=
2302 btcoexist
->btc_read_4byte(btcoexist
, 0x434);
2303 coex_dm
->backup_retry_limit
=
2304 btcoexist
->btc_read_2byte(btcoexist
, 0x42a);
2305 coex_dm
->backup_ampdu_max_time
=
2306 btcoexist
->btc_read_1byte(btcoexist
, 0x456);
2309 /* WiFi goto standby while GNT_BT 0-->1 */
2310 btcoexist
->btc_set_rf_reg(btcoexist
, BTC_RF_A
, 0x1, 0xfffff, 0x780);
2311 /* BT goto standby while GNT_BT 1-->0 */
2312 btcoexist
->btc_set_rf_reg(btcoexist
, BTC_RF_A
, 0x2, 0xfffff, 0x500);
2314 btcoexist
->btc_write_1byte(btcoexist
, 0x974, 0xff);
2315 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x944, 0x3, 0x3);
2316 btcoexist
->btc_write_1byte(btcoexist
, 0x930, 0x77);
2318 /* BT calibration check */
2319 while (cnt_bt_cal_chk
<= 20) {
2320 u32tmp
= btcoexist
->btc_read_4byte(btcoexist
, 0x49d);
2322 if (u32tmp
& BIT0
) {
2323 btc_iface_dbg(INTF_INIT
,
2324 "[BTCoex], ########### BT calibration(cnt=%d) ###########\n",
2328 btc_iface_dbg(INTF_INIT
,
2329 "[BTCoex], ********** BT NOT calibration (cnt=%d)**********\n",
2335 /* 0x790[5:0] = 0x5 */
2336 u8tmp
= btcoexist
->btc_read_1byte(btcoexist
, 0x790);
2339 btcoexist
->btc_write_1byte(btcoexist
, 0x790, u8tmp
);
2341 /* Enable counter statistics */
2342 /*0x76e[3] =1, WLAN_Act control by PTA */
2343 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0xc);
2344 btcoexist
->btc_write_1byte(btcoexist
, 0x778, 0x1);
2345 btcoexist
->btc_write_1byte_bitmask(btcoexist
, 0x40, 0x20, 0x1);
2348 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_PTA
, true, false);
2350 halbtc8723b1ant_coex_table_with_type(btcoexist
, FORCE_EXEC
, 0);
2353 static void halbtc8723b1ant_wifi_off_hw_cfg(struct btc_coexist
*btcoexist
)
2355 /* set wlan_act to low */
2356 btcoexist
->btc_write_1byte(btcoexist
, 0x76e, 0x4);
2359 /**************************************************************
2360 * work around function start with wa_halbtc8723b1ant_
2361 **************************************************************/
2362 /**************************************************************
2363 * extern function start with EXhalbtc8723b1ant_
2364 **************************************************************/
2366 void ex_halbtc8723b1ant_init_hwconfig(struct btc_coexist
*btcoexist
)
2368 halbtc8723b1ant_init_hw_config(btcoexist
, true);
2371 void ex_halbtc8723b1ant_init_coex_dm(struct btc_coexist
*btcoexist
)
2373 btc_iface_dbg(INTF_INIT
,
2374 "[BTCoex], Coex Mechanism Init!!\n");
2376 btcoexist
->stop_coex_dm
= false;
2378 halbtc8723b1ant_init_coex_dm(btcoexist
);
2380 halbtc8723b1ant_query_bt_info(btcoexist
);
2383 void ex_halbtc8723b1ant_display_coex_info(struct btc_coexist
*btcoexist
)
2385 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
2386 struct btc_stack_info
*stack_info
= &btcoexist
->stack_info
;
2387 struct btc_bt_link_info
*bt_link_info
= &btcoexist
->bt_link_info
;
2388 struct rtl_priv
*rtlpriv
= btcoexist
->adapter
;
2389 u8 u8tmp
[4], i
, bt_info_ext
, pstdmacase
= 0;
2392 bool roam
= false, scan
= false;
2393 bool link
= false, wifi_under_5g
= false;
2394 bool bt_hs_on
= false, wifi_busy
= false;
2395 s32 wifi_rssi
= 0, bt_hs_rssi
= 0;
2396 u32 wifi_bw
, wifi_traffic_dir
, fa_ofdm
, fa_cck
, wifi_link_status
;
2397 u8 wifi_dot11_chnl
, wifi_hs_chnl
;
2398 u32 fw_ver
= 0, bt_patch_ver
= 0;
2400 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2401 "\r\n ============[BT Coexist info]============");
2403 if (btcoexist
->manual_control
) {
2404 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2405 "\r\n ============[Under Manual Control]==========");
2406 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2407 "\r\n ==========================================");
2409 if (btcoexist
->stop_coex_dm
) {
2410 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2411 "\r\n ============[Coex is STOPPED]============");
2412 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2413 "\r\n ==========================================");
2416 if (!board_info
->bt_exist
) {
2417 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n BT not exists !!!");
2421 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/ %d/ %d",
2422 "Ant PG Num/ Ant Mech/ Ant Pos:",
2423 board_info
->pg_ant_num
, board_info
->btdm_ant_num
,
2424 board_info
->btdm_ant_pos
);
2426 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %s / %d",
2427 "BT stack/ hci ext ver",
2428 ((stack_info
->profile_notified
) ? "Yes" : "No"),
2429 stack_info
->hci_version
);
2431 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_BT_PATCH_VER
, &bt_patch_ver
);
2432 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
2433 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2434 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2435 "CoexVer/ FwVer/ PatchVer",
2436 glcoex_ver_date_8723b_1ant
, glcoex_ver_8723b_1ant
,
2437 fw_ver
, bt_patch_ver
, bt_patch_ver
);
2439 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2440 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_DOT11_CHNL
,
2442 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_HS_CHNL
, &wifi_hs_chnl
);
2443 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d / %d(%d)",
2444 "Dot11 channel / HsChnl(HsMode)",
2445 wifi_dot11_chnl
, wifi_hs_chnl
, bt_hs_on
);
2447 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %3ph ",
2448 "H2C Wifi inform bt chnl Info",
2449 coex_dm
->wifi_chnl_info
);
2451 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_WIFI_RSSI
, &wifi_rssi
);
2452 btcoexist
->btc_get(btcoexist
, BTC_GET_S4_HS_RSSI
, &bt_hs_rssi
);
2453 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/ %d",
2454 "Wifi rssi/ HS rssi", wifi_rssi
, bt_hs_rssi
);
2456 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_SCAN
, &scan
);
2457 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_LINK
, &link
);
2458 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_ROAM
, &roam
);
2459 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/ %d/ %d ",
2460 "Wifi link/ roam/ scan", link
, roam
, scan
);
2462 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_UNDER_5G
,
2464 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2465 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_BUSY
, &wifi_busy
);
2466 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION
,
2469 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %s / %s/ %s ",
2470 "Wifi status", (wifi_under_5g
? "5G" : "2.4G"),
2471 ((BTC_WIFI_BW_LEGACY
== wifi_bw
) ? "Legacy" :
2472 (((BTC_WIFI_BW_HT40
== wifi_bw
) ? "HT40" : "HT20"))),
2473 ((!wifi_busy
) ? "idle" :
2474 ((BTC_WIFI_TRAFFIC_TX
== wifi_traffic_dir
) ?
2475 "uplink" : "downlink")));
2477 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_LINK_STATUS
,
2479 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
2480 "sta/vwifi/hs/p2pGo/p2pGc",
2481 ((wifi_link_status
& WIFI_STA_CONNECTED
) ? 1 : 0),
2482 ((wifi_link_status
& WIFI_AP_CONNECTED
) ? 1 : 0),
2483 ((wifi_link_status
& WIFI_HS_CONNECTED
) ? 1 : 0),
2484 ((wifi_link_status
& WIFI_P2P_GO_CONNECTED
) ? 1 : 0),
2485 ((wifi_link_status
& WIFI_P2P_GC_CONNECTED
) ? 1 : 0));
2487 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = [%s/ %d/ %d] ",
2488 "BT [status/ rssi/ retryCnt]",
2489 ((btcoexist
->bt_info
.bt_disabled
) ? ("disabled") :
2490 ((coex_sta
->c2h_bt_inquiry_page
) ? ("inquiry/page scan") :
2491 ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
==
2492 coex_dm
->bt_status
) ?
2493 "non-connected idle" :
2494 ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
==
2495 coex_dm
->bt_status
) ?
2496 "connected-idle" : "busy")))),
2497 coex_sta
->bt_rssi
, coex_sta
->bt_retry_cnt
);
2499 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2500 "\r\n %-35s = %d / %d / %d / %d",
2501 "SCO/HID/PAN/A2DP", bt_link_info
->sco_exist
,
2502 bt_link_info
->hid_exist
, bt_link_info
->pan_exist
,
2503 bt_link_info
->a2dp_exist
);
2504 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_BT_LINK_INFO
);
2506 bt_info_ext
= coex_sta
->bt_info_ext
;
2507 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %s",
2508 "BT Info A2DP rate",
2509 (bt_info_ext
& BIT0
) ? "Basic rate" : "EDR rate");
2511 for (i
= 0; i
< BT_INFO_SRC_8723B_1ANT_MAX
; i
++) {
2512 if (coex_sta
->bt_info_c2h_cnt
[i
]) {
2513 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2514 "\r\n %-35s = %7ph(%d)",
2515 GLBtInfoSrc8723b1Ant
[i
],
2516 coex_sta
->bt_info_c2h
[i
],
2517 coex_sta
->bt_info_c2h_cnt
[i
]);
2520 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2521 "\r\n %-35s = %s/%s, (0x%x/0x%x)",
2522 "PS state, IPS/LPS, (lps/rpwm)",
2523 ((coex_sta
->under_ips
? "IPS ON" : "IPS OFF")),
2524 ((coex_sta
->under_lps
? "LPS ON" : "LPS OFF")),
2525 btcoexist
->bt_info
.lps_val
,
2526 btcoexist
->bt_info
.rpwm_val
);
2527 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_FW_PWR_MODE_CMD
);
2529 if (!btcoexist
->manual_control
) {
2531 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s",
2532 "============[Sw mechanism]============");
2534 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/",
2535 "SM[LowPenaltyRA]", coex_dm
->cur_low_penalty_ra
);
2537 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %s/ %s/ %d ",
2538 "DelBA/ BtCtrlAgg/ AggSize",
2539 (btcoexist
->bt_info
.reject_agg_pkt
? "Yes" : "No"),
2540 (btcoexist
->bt_info
.bt_ctrl_buf_size
? "Yes" : "No"),
2541 btcoexist
->bt_info
.agg_buf_size
);
2543 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x ",
2544 "Rate Mask", btcoexist
->bt_info
.ra_mask
);
2547 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s",
2548 "============[Fw mechanism]============");
2550 pstdmacase
= coex_dm
->cur_ps_tdma
;
2551 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2552 "\r\n %-35s = %5ph case-%d (auto:%d)",
2553 "PS TDMA", coex_dm
->ps_tdma_para
,
2554 pstdmacase
, coex_dm
->auto_tdma_adjust
);
2556 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d ",
2557 "IgnWlanAct", coex_dm
->cur_ignore_wlan_act
);
2559 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x ",
2560 "Latest error condition(should be 0)",
2561 coex_dm
->error_condition
);
2565 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s",
2566 "============[Hw setting]============");
2568 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2569 "backup ARFR1/ARFR2/RL/AMaxTime", coex_dm
->backup_arfr_cnt1
,
2570 coex_dm
->backup_arfr_cnt2
, coex_dm
->backup_retry_limit
,
2571 coex_dm
->backup_ampdu_max_time
);
2573 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x430);
2574 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x434);
2575 u16tmp
[0] = btcoexist
->btc_read_2byte(btcoexist
, 0x42a);
2576 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x456);
2577 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2578 "0x430/0x434/0x42a/0x456",
2579 u32tmp
[0], u32tmp
[1], u16tmp
[0], u8tmp
[0]);
2581 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x778);
2582 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x6cc);
2583 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x880);
2584 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2585 "0x778/0x6cc/0x880[29:25]", u8tmp
[0], u32tmp
[0],
2586 (u32tmp
[1] & 0x3e000000) >> 25);
2588 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x948);
2589 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x67);
2590 u8tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0x765);
2591 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2592 "0x948/ 0x67[5] / 0x765",
2593 u32tmp
[0], ((u8tmp
[0] & 0x20) >> 5), u8tmp
[1]);
2595 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x92c);
2596 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x930);
2597 u32tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0x944);
2598 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2599 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
2600 u32tmp
[0] & 0x3, u32tmp
[1] & 0xff, u32tmp
[2] & 0x3);
2602 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x39);
2603 u8tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0x40);
2604 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x4c);
2605 u8tmp
[2] = btcoexist
->btc_read_1byte(btcoexist
, 0x64);
2606 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
2607 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2608 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
2609 ((u8tmp
[0] & 0x8)>>3), u8tmp
[1],
2610 ((u32tmp
[0] & 0x01800000) >> 23), u8tmp
[2] & 0x1);
2612 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x550);
2613 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x522);
2614 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x",
2615 "0x550(bcn ctrl)/0x522", u32tmp
[0], u8tmp
[0]);
2617 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xc50);
2618 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0x49c);
2619 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x",
2620 "0xc50(dig)/0x49c(null-drop)", u32tmp
[0] & 0xff, u8tmp
[0]);
2622 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0xda0);
2623 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0xda4);
2624 u32tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0xda8);
2625 u32tmp
[3] = btcoexist
->btc_read_4byte(btcoexist
, 0xcf0);
2627 u8tmp
[0] = btcoexist
->btc_read_1byte(btcoexist
, 0xa5b);
2628 u8tmp
[1] = btcoexist
->btc_read_1byte(btcoexist
, 0xa5c);
2630 fa_ofdm
= ((u32tmp
[0] & 0xffff0000) >> 16) +
2631 ((u32tmp
[1] & 0xffff0000) >> 16) +
2632 (u32tmp
[1] & 0xffff) +
2633 (u32tmp
[2] & 0xffff) +
2634 ((u32tmp
[3] & 0xffff0000) >> 16) +
2635 (u32tmp
[3] & 0xffff);
2636 fa_cck
= (u8tmp
[0] << 8) + u8tmp
[1];
2638 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2639 "OFDM-CCA/OFDM-FA/CCK-FA",
2640 u32tmp
[0] & 0xffff, fa_ofdm
, fa_cck
);
2642 u32tmp
[0] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c0);
2643 u32tmp
[1] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c4);
2644 u32tmp
[2] = btcoexist
->btc_read_4byte(btcoexist
, 0x6c8);
2645 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2646 "0x6c0/0x6c4/0x6c8(coexTable)",
2647 u32tmp
[0], u32tmp
[1], u32tmp
[2]);
2649 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/ %d",
2650 "0x770(high-pri rx/tx)", coex_sta
->high_priority_rx
,
2651 coex_sta
->high_priority_tx
);
2652 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "\r\n %-35s = %d/ %d",
2653 "0x774(low-pri rx/tx)", coex_sta
->low_priority_rx
,
2654 coex_sta
->low_priority_tx
);
2655 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 1)
2656 halbtc8723b1ant_monitor_bt_ctr(btcoexist
);
2658 btcoexist
->btc_disp_dbg_msg(btcoexist
, BTC_DBG_DISP_COEX_STATISTICS
);
2661 void ex_halbtc8723b1ant_ips_notify(struct btc_coexist
*btcoexist
, u8 type
)
2663 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
)
2666 if (BTC_IPS_ENTER
== type
) {
2667 btc_iface_dbg(INTF_NOTIFY
,
2668 "[BTCoex], IPS ENTER notify\n");
2669 coex_sta
->under_ips
= true;
2671 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
,
2673 /* set PTA control */
2674 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 0);
2675 halbtc8723b1ant_coex_table_with_type(btcoexist
,
2677 halbtc8723b1ant_wifi_off_hw_cfg(btcoexist
);
2678 } else if (BTC_IPS_LEAVE
== type
) {
2679 btc_iface_dbg(INTF_NOTIFY
,
2680 "[BTCoex], IPS LEAVE notify\n");
2681 coex_sta
->under_ips
= false;
2683 halbtc8723b1ant_init_hw_config(btcoexist
, false);
2684 halbtc8723b1ant_init_coex_dm(btcoexist
);
2685 halbtc8723b1ant_query_bt_info(btcoexist
);
2689 void ex_halbtc8723b1ant_lps_notify(struct btc_coexist
*btcoexist
, u8 type
)
2691 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
)
2694 if (BTC_LPS_ENABLE
== type
) {
2695 btc_iface_dbg(INTF_NOTIFY
,
2696 "[BTCoex], LPS ENABLE notify\n");
2697 coex_sta
->under_lps
= true;
2698 } else if (BTC_LPS_DISABLE
== type
) {
2699 btc_iface_dbg(INTF_NOTIFY
,
2700 "[BTCoex], LPS DISABLE notify\n");
2701 coex_sta
->under_lps
= false;
2705 void ex_halbtc8723b1ant_scan_notify(struct btc_coexist
*btcoexist
, u8 type
)
2707 bool wifi_connected
= false, bt_hs_on
= false;
2708 u32 wifi_link_status
= 0;
2709 u32 num_of_wifi_link
= 0;
2710 bool bt_ctrl_agg_buf_size
= false;
2711 u8 agg_buf_size
= 5;
2713 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
2714 btcoexist
->bt_info
.bt_disabled
)
2717 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2718 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2721 halbtc8723b1ant_query_bt_info(btcoexist
);
2723 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_LINK_STATUS
,
2725 num_of_wifi_link
= wifi_link_status
>> 16;
2726 if (num_of_wifi_link
>= 2) {
2727 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
2728 halbtc8723b1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
2729 bt_ctrl_agg_buf_size
, agg_buf_size
);
2730 halbtc8723b1ant_action_wifi_multiport(btcoexist
);
2734 if (coex_sta
->c2h_bt_inquiry_page
) {
2735 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
2737 } else if (bt_hs_on
) {
2738 halbtc8723b1ant_action_hs(btcoexist
);
2742 if (BTC_SCAN_START
== type
) {
2743 btc_iface_dbg(INTF_NOTIFY
,
2744 "[BTCoex], SCAN START notify\n");
2745 if (!wifi_connected
) /* non-connected scan */
2746 btc8723b1ant_action_wifi_not_conn_scan(btcoexist
);
2747 else /* wifi is connected */
2748 btc8723b1ant_action_wifi_conn_scan(btcoexist
);
2749 } else if (BTC_SCAN_FINISH
== type
) {
2750 btc_iface_dbg(INTF_NOTIFY
,
2751 "[BTCoex], SCAN FINISH notify\n");
2752 if (!wifi_connected
) /* non-connected scan */
2753 btc8723b1ant_action_wifi_not_conn(btcoexist
);
2755 halbtc8723b1ant_action_wifi_connected(btcoexist
);
2759 void ex_halbtc8723b1ant_connect_notify(struct btc_coexist
*btcoexist
, u8 type
)
2761 bool wifi_connected
= false, bt_hs_on
= false;
2762 u32 wifi_link_status
= 0;
2763 u32 num_of_wifi_link
= 0;
2764 bool bt_ctrl_agg_buf_size
= false;
2765 u8 agg_buf_size
= 5;
2767 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
2768 btcoexist
->bt_info
.bt_disabled
)
2771 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_LINK_STATUS
,
2773 num_of_wifi_link
= wifi_link_status
>>16;
2774 if (num_of_wifi_link
>= 2) {
2775 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
2776 halbtc8723b1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
2777 bt_ctrl_agg_buf_size
, agg_buf_size
);
2778 halbtc8723b1ant_action_wifi_multiport(btcoexist
);
2782 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2783 if (coex_sta
->c2h_bt_inquiry_page
) {
2784 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
2786 } else if (bt_hs_on
) {
2787 halbtc8723b1ant_action_hs(btcoexist
);
2791 if (BTC_ASSOCIATE_START
== type
) {
2792 btc_iface_dbg(INTF_NOTIFY
,
2793 "[BTCoex], CONNECT START notify\n");
2794 btc8723b1ant_act_wifi_not_conn_asso_auth(btcoexist
);
2795 } else if (BTC_ASSOCIATE_FINISH
== type
) {
2796 btc_iface_dbg(INTF_NOTIFY
,
2797 "[BTCoex], CONNECT FINISH notify\n");
2799 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2801 if (!wifi_connected
) /* non-connected scan */
2802 btc8723b1ant_action_wifi_not_conn(btcoexist
);
2804 halbtc8723b1ant_action_wifi_connected(btcoexist
);
2808 void ex_halbtc8723b1ant_media_status_notify(struct btc_coexist
*btcoexist
,
2811 u8 h2c_parameter
[3] = {0};
2815 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
2816 btcoexist
->bt_info
.bt_disabled
)
2819 if (BTC_MEDIA_CONNECT
== type
)
2820 btc_iface_dbg(INTF_NOTIFY
,
2821 "[BTCoex], MEDIA connect notify\n");
2823 btc_iface_dbg(INTF_NOTIFY
,
2824 "[BTCoex], MEDIA disconnect notify\n");
2826 /* only 2.4G we need to inform bt the chnl mask */
2827 btcoexist
->btc_get(btcoexist
, BTC_GET_U1_WIFI_CENTRAL_CHNL
,
2830 if ((BTC_MEDIA_CONNECT
== type
) &&
2831 (wifiCentralChnl
<= 14)) {
2832 h2c_parameter
[0] = 0x0;
2833 h2c_parameter
[1] = wifiCentralChnl
;
2834 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_BW
, &wifi_bw
);
2835 if (BTC_WIFI_BW_HT40
== wifi_bw
)
2836 h2c_parameter
[2] = 0x30;
2838 h2c_parameter
[2] = 0x20;
2841 coex_dm
->wifi_chnl_info
[0] = h2c_parameter
[0];
2842 coex_dm
->wifi_chnl_info
[1] = h2c_parameter
[1];
2843 coex_dm
->wifi_chnl_info
[2] = h2c_parameter
[2];
2845 btc_alg_dbg(ALGO_TRACE_FW_EXEC
,
2846 "[BTCoex], FW write 0x66 = 0x%x\n",
2847 h2c_parameter
[0] << 16 | h2c_parameter
[1] << 8 |
2850 btcoexist
->btc_fill_h2c(btcoexist
, 0x66, 3, h2c_parameter
);
2853 void ex_halbtc8723b1ant_special_packet_notify(struct btc_coexist
*btcoexist
,
2856 bool bt_hs_on
= false;
2857 u32 wifi_link_status
= 0;
2858 u32 num_of_wifi_link
= 0;
2859 bool bt_ctrl_agg_buf_size
= false;
2860 u8 agg_buf_size
= 5;
2862 if (btcoexist
->manual_control
|| btcoexist
->stop_coex_dm
||
2863 btcoexist
->bt_info
.bt_disabled
)
2866 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_LINK_STATUS
,
2868 num_of_wifi_link
= wifi_link_status
>> 16;
2869 if (num_of_wifi_link
>= 2) {
2870 halbtc8723b1ant_limited_tx(btcoexist
, NORMAL_EXEC
, 0, 0, 0, 0);
2871 halbtc8723b1ant_limited_rx(btcoexist
, NORMAL_EXEC
, false,
2872 bt_ctrl_agg_buf_size
, agg_buf_size
);
2873 halbtc8723b1ant_action_wifi_multiport(btcoexist
);
2877 coex_sta
->special_pkt_period_cnt
= 0;
2879 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_HS_OPERATION
, &bt_hs_on
);
2880 if (coex_sta
->c2h_bt_inquiry_page
) {
2881 halbtc8723b1ant_action_bt_inquiry(btcoexist
);
2883 } else if (bt_hs_on
) {
2884 halbtc8723b1ant_action_hs(btcoexist
);
2888 if (BTC_PACKET_DHCP
== type
||
2889 BTC_PACKET_EAPOL
== type
) {
2890 btc_iface_dbg(INTF_NOTIFY
,
2891 "[BTCoex], special Packet(%d) notify\n", type
);
2892 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist
);
2896 void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist
*btcoexist
,
2897 u8
*tmp_buf
, u8 length
)
2900 u8 i
, rsp_source
= 0;
2901 bool wifi_connected
= false;
2902 bool bt_busy
= false;
2904 coex_sta
->c2h_bt_info_req_sent
= false;
2906 rsp_source
= tmp_buf
[0] & 0xf;
2907 if (rsp_source
>= BT_INFO_SRC_8723B_1ANT_MAX
)
2908 rsp_source
= BT_INFO_SRC_8723B_1ANT_WIFI_FW
;
2909 coex_sta
->bt_info_c2h_cnt
[rsp_source
]++;
2911 btc_iface_dbg(INTF_NOTIFY
,
2912 "[BTCoex], Bt info[%d], length=%d, hex data = [",
2913 rsp_source
, length
);
2914 for (i
= 0; i
< length
; i
++) {
2915 coex_sta
->bt_info_c2h
[rsp_source
][i
] = tmp_buf
[i
];
2917 bt_info
= tmp_buf
[i
];
2918 if (i
== length
- 1)
2919 btc_iface_dbg(INTF_NOTIFY
,
2920 "0x%02x]\n", tmp_buf
[i
]);
2922 btc_iface_dbg(INTF_NOTIFY
,
2923 "0x%02x, ", tmp_buf
[i
]);
2926 if (BT_INFO_SRC_8723B_1ANT_WIFI_FW
!= rsp_source
) {
2927 coex_sta
->bt_retry_cnt
= /* [3:0] */
2928 coex_sta
->bt_info_c2h
[rsp_source
][2] & 0xf;
2931 coex_sta
->bt_info_c2h
[rsp_source
][3] * 2 + 10;
2933 coex_sta
->bt_info_ext
=
2934 coex_sta
->bt_info_c2h
[rsp_source
][4];
2936 /* Here we need to resend some wifi info to BT
2937 * because bt is reset and loss of the info.
2939 if (coex_sta
->bt_info_ext
& BIT1
) {
2940 btc_alg_dbg(ALGO_TRACE
,
2941 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
2942 btcoexist
->btc_get(btcoexist
, BTC_GET_BL_WIFI_CONNECTED
,
2945 ex_halbtc8723b1ant_media_status_notify(btcoexist
,
2948 ex_halbtc8723b1ant_media_status_notify(btcoexist
,
2949 BTC_MEDIA_DISCONNECT
);
2952 if (coex_sta
->bt_info_ext
& BIT3
) {
2953 if (!btcoexist
->manual_control
&&
2954 !btcoexist
->stop_coex_dm
) {
2955 btc_alg_dbg(ALGO_TRACE
,
2956 "[BTCoex], BT ext info bit3 check, set BT NOT ignore Wlan active!!\n");
2957 halbtc8723b1ant_ignore_wlan_act(btcoexist
,
2962 /* BT already NOT ignore Wlan active, do nothing here.*/
2964 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
2965 if (coex_sta
->bt_info_ext
& BIT4
) {
2966 /* BT auto report already enabled, do nothing */
2968 halbtc8723b1ant_bt_auto_report(btcoexist
, FORCE_EXEC
,
2974 /* check BIT2 first ==> check if bt is under inquiry or page scan */
2975 if (bt_info
& BT_INFO_8723B_1ANT_B_INQ_PAGE
)
2976 coex_sta
->c2h_bt_inquiry_page
= true;
2978 coex_sta
->c2h_bt_inquiry_page
= false;
2980 /* set link exist status */
2981 if (!(bt_info
& BT_INFO_8723B_1ANT_B_CONNECTION
)) {
2982 coex_sta
->bt_link_exist
= false;
2983 coex_sta
->pan_exist
= false;
2984 coex_sta
->a2dp_exist
= false;
2985 coex_sta
->hid_exist
= false;
2986 coex_sta
->sco_exist
= false;
2987 } else { /* connection exists */
2988 coex_sta
->bt_link_exist
= true;
2989 if (bt_info
& BT_INFO_8723B_1ANT_B_FTP
)
2990 coex_sta
->pan_exist
= true;
2992 coex_sta
->pan_exist
= false;
2993 if (bt_info
& BT_INFO_8723B_1ANT_B_A2DP
)
2994 coex_sta
->a2dp_exist
= true;
2996 coex_sta
->a2dp_exist
= false;
2997 if (bt_info
& BT_INFO_8723B_1ANT_B_HID
)
2998 coex_sta
->hid_exist
= true;
3000 coex_sta
->hid_exist
= false;
3001 if (bt_info
& BT_INFO_8723B_1ANT_B_SCO_ESCO
)
3002 coex_sta
->sco_exist
= true;
3004 coex_sta
->sco_exist
= false;
3007 halbtc8723b1ant_update_bt_link_info(btcoexist
);
3009 if (!(bt_info
&BT_INFO_8723B_1ANT_B_CONNECTION
)) {
3010 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
;
3011 btc_alg_dbg(ALGO_TRACE
,
3012 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!\n");
3013 /* connection exists but no busy */
3014 } else if (bt_info
== BT_INFO_8723B_1ANT_B_CONNECTION
) {
3015 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE
;
3016 btc_alg_dbg(ALGO_TRACE
,
3017 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3018 } else if ((bt_info
& BT_INFO_8723B_1ANT_B_SCO_ESCO
) ||
3019 (bt_info
& BT_INFO_8723B_1ANT_B_SCO_BUSY
)) {
3020 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_SCO_BUSY
;
3021 btc_alg_dbg(ALGO_TRACE
,
3022 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3023 } else if (bt_info
& BT_INFO_8723B_1ANT_B_ACL_BUSY
) {
3024 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY
!= coex_dm
->bt_status
)
3025 coex_dm
->auto_tdma_adjust
= false;
3027 coex_dm
->bt_status
= BT_8723B_1ANT_BT_STATUS_ACL_BUSY
;
3028 btc_alg_dbg(ALGO_TRACE
,
3029 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3031 coex_dm
->bt_status
=
3032 BT_8723B_1ANT_BT_STATUS_MAX
;
3033 btc_alg_dbg(ALGO_TRACE
,
3034 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n");
3037 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY
== coex_dm
->bt_status
) ||
3038 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY
== coex_dm
->bt_status
) ||
3039 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY
== coex_dm
->bt_status
))
3043 btcoexist
->btc_set(btcoexist
, BTC_SET_BL_BT_TRAFFIC_BUSY
, &bt_busy
);
3045 halbtc8723b1ant_run_coexist_mechanism(btcoexist
);
3048 void ex_halbtc8723b1ant_halt_notify(struct btc_coexist
*btcoexist
)
3050 btc_iface_dbg(INTF_NOTIFY
, "[BTCoex], Halt notify\n");
3052 btcoexist
->stop_coex_dm
= true;
3054 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
, false, true);
3056 halbtc8723b1ant_wifi_off_hw_cfg(btcoexist
);
3057 halbtc8723b1ant_ignore_wlan_act(btcoexist
, FORCE_EXEC
, true);
3059 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
3061 halbtc8723b1ant_ps_tdma(btcoexist
, FORCE_EXEC
, false, 0);
3063 ex_halbtc8723b1ant_media_status_notify(btcoexist
, BTC_MEDIA_DISCONNECT
);
3066 void ex_halbtc8723b1ant_pnp_notify(struct btc_coexist
*btcoexist
, u8 pnp_state
)
3068 btc_iface_dbg(INTF_NOTIFY
, "[BTCoex], Pnp notify\n");
3070 if (BTC_WIFI_PNP_SLEEP
== pnp_state
) {
3071 btc_iface_dbg(INTF_NOTIFY
,
3072 "[BTCoex], Pnp notify to SLEEP\n");
3073 btcoexist
->stop_coex_dm
= true;
3074 halbtc8723b1ant_SetAntPath(btcoexist
, BTC_ANT_PATH_BT
, false,
3076 halbtc8723b1ant_power_save_state(btcoexist
, BTC_PS_WIFI_NATIVE
,
3078 halbtc8723b1ant_ps_tdma(btcoexist
, NORMAL_EXEC
, false, 0);
3079 halbtc8723b1ant_coex_table_with_type(btcoexist
, NORMAL_EXEC
, 2);
3080 halbtc8723b1ant_wifi_off_hw_cfg(btcoexist
);
3081 } else if (BTC_WIFI_PNP_WAKE_UP
== pnp_state
) {
3082 btc_iface_dbg(INTF_NOTIFY
,
3083 "[BTCoex], Pnp notify to WAKE UP\n");
3084 btcoexist
->stop_coex_dm
= false;
3085 halbtc8723b1ant_init_hw_config(btcoexist
, false);
3086 halbtc8723b1ant_init_coex_dm(btcoexist
);
3087 halbtc8723b1ant_query_bt_info(btcoexist
);
3091 void ex_halbtc8723b1ant_coex_dm_reset(struct btc_coexist
*btcoexist
)
3093 btc_alg_dbg(ALGO_TRACE
,
3094 "[BTCoex], *****************Coex DM Reset****************\n");
3096 halbtc8723b1ant_init_hw_config(btcoexist
, false);
3097 btcoexist
->btc_set_rf_reg(btcoexist
, BTC_RF_A
, 0x1, 0xfffff, 0x0);
3098 btcoexist
->btc_set_rf_reg(btcoexist
, BTC_RF_A
, 0x2, 0xfffff, 0x0);
3099 halbtc8723b1ant_init_coex_dm(btcoexist
);
3102 void ex_halbtc8723b1ant_periodical(struct btc_coexist
*btcoexist
)
3104 struct btc_board_info
*board_info
= &btcoexist
->board_info
;
3105 struct btc_stack_info
*stack_info
= &btcoexist
->stack_info
;
3106 static u8 dis_ver_info_cnt
;
3107 u32 fw_ver
= 0, bt_patch_ver
= 0;
3109 btc_alg_dbg(ALGO_TRACE
,
3110 "[BTCoex], ==========================Periodical===========================\n");
3112 if (dis_ver_info_cnt
<= 5) {
3113 dis_ver_info_cnt
+= 1;
3114 btc_iface_dbg(INTF_INIT
,
3115 "[BTCoex], ****************************************************************\n");
3116 btc_iface_dbg(INTF_INIT
,
3117 "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
3118 board_info
->pg_ant_num
, board_info
->btdm_ant_num
,
3119 board_info
->btdm_ant_pos
);
3120 btc_iface_dbg(INTF_INIT
,
3121 "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3122 stack_info
->profile_notified
? "Yes" : "No",
3123 stack_info
->hci_version
);
3124 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_BT_PATCH_VER
,
3126 btcoexist
->btc_get(btcoexist
, BTC_GET_U4_WIFI_FW_VER
, &fw_ver
);
3127 btc_iface_dbg(INTF_INIT
,
3128 "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3129 glcoex_ver_date_8723b_1ant
,
3130 glcoex_ver_8723b_1ant
, fw_ver
,
3131 bt_patch_ver
, bt_patch_ver
);
3132 btc_iface_dbg(INTF_INIT
,
3133 "[BTCoex], ****************************************************************\n");
3136 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
3137 halbtc8723b1ant_query_bt_info(btcoexist
);
3138 halbtc8723b1ant_monitor_bt_ctr(btcoexist
);
3139 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist
);
3141 if (btc8723b1ant_is_wifi_status_changed(btcoexist
) ||
3142 coex_dm
->auto_tdma_adjust
) {
3143 halbtc8723b1ant_run_coexist_mechanism(btcoexist
);
3146 coex_sta
->special_pkt_period_cnt
++;