1 /* SPDX-License-Identifier: GPL-2.0 */
2 /******************************************************************************
3 *
4 * Copyright(c) 2016 - 2017 Realtek Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 *****************************************************************************/
16
17 /* ************************************************************
18 * Description:
19 *
20 * This file is for RTL8723D Co-exist mechanism
21 *
22 * History
23 * 2012/11/15 Cosa first check in.
24 *
25 * ************************************************************ */
26
27 /* ************************************************************
28 * include files
29 * ************************************************************ */
30 #include "mp_precomp.h"
31
32 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
33
34 #if (RTL8723D_SUPPORT == 1)
35 /* ************************************************************
36 * Global variables, these are static variables
37 * ************************************************************ */
38 static u8 *trace_buf = &gl_btc_trace_buf[0];
39 static struct coex_dm_8723d_2ant glcoex_dm_8723d_2ant;
40 static struct coex_dm_8723d_2ant *coex_dm = &glcoex_dm_8723d_2ant;
41 static struct coex_sta_8723d_2ant glcoex_sta_8723d_2ant;
42 static struct coex_sta_8723d_2ant *coex_sta = &glcoex_sta_8723d_2ant;
43 static struct psdscan_sta_8723d_2ant gl_psd_scan_8723d_2ant;
44 static struct psdscan_sta_8723d_2ant *psd_scan = &gl_psd_scan_8723d_2ant;
45
46 const char *const glbt_info_src_8723d_2ant[] = {
47 "BT Info[wifi fw]",
48 "BT Info[bt rsp]",
49 "BT Info[bt auto report]",
50 };
51 /* ************************************************************
52 * BtCoex Version Format:
53 * 1. date : glcoex_ver_date_XXXXX_1ant
54 * 2. WifiCoexVersion : glcoex_ver_XXXX_1ant
55 * 3. BtCoexVersion : glcoex_ver_btdesired_XXXXX_1ant
56 * 4. others : glcoex_ver_XXXXXX_XXXXX_1ant
57 *
58 * Variable should be indicated IC and Antenna numbers !!!
59 * Please strictly follow this order and naming style !!!
60 *
61 * ************************************************************ */
62 u32 glcoex_ver_date_8723d_2ant = 20170814;
63 u32 glcoex_ver_8723d_2ant = 0x1b;
64 u32 glcoex_ver_btdesired_8723d_2ant = 0x16;
65
66
67 /* ************************************************************
68 * local function proto type if needed
69 * ************************************************************
70 * ************************************************************
71 * local function start with halbtc8723d2ant_
72 * ************************************************************ */
halbtc8723d2ant_bt_rssi_state(IN struct btc_coexist * btcoexist,u8 * ppre_bt_rssi_state,u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)73 u8 halbtc8723d2ant_bt_rssi_state(IN struct btc_coexist *btcoexist,
74 u8 *ppre_bt_rssi_state, u8 level_num,
75 u8 rssi_thresh, u8 rssi_thresh1)
76 {
77 s32 bt_rssi = 0;
78 u8 bt_rssi_state = *ppre_bt_rssi_state;
79
80 bt_rssi = coex_sta->bt_rssi;
81
82 if (level_num == 2) {
83 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
84 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
85 if (bt_rssi >= (rssi_thresh +
86 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
87 bt_rssi_state = BTC_RSSI_STATE_HIGH;
88 else
89 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
90 } else {
91 if (bt_rssi < rssi_thresh)
92 bt_rssi_state = BTC_RSSI_STATE_LOW;
93 else
94 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
95 }
96 } else if (level_num == 3) {
97 if (rssi_thresh > rssi_thresh1) {
98 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
99 "[BTCoex], BT Rssi thresh error!!\n");
100 BTC_TRACE(trace_buf);
101 return *ppre_bt_rssi_state;
102 }
103
104 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
105 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
106 if (bt_rssi >= (rssi_thresh +
107 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
108 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
109 else
110 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
111 } else if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
112 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
113 if (bt_rssi >= (rssi_thresh1 +
114 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
115 bt_rssi_state = BTC_RSSI_STATE_HIGH;
116 else if (bt_rssi < rssi_thresh)
117 bt_rssi_state = BTC_RSSI_STATE_LOW;
118 else
119 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
120 } else {
121 if (bt_rssi < rssi_thresh1)
122 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
123 else
124 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
125 }
126 }
127
128 *ppre_bt_rssi_state = bt_rssi_state;
129
130 return bt_rssi_state;
131 }
132
halbtc8723d2ant_wifi_rssi_state(IN struct btc_coexist * btcoexist,IN u8 * pprewifi_rssi_state,IN u8 level_num,IN u8 rssi_thresh,IN u8 rssi_thresh1)133 u8 halbtc8723d2ant_wifi_rssi_state(IN struct btc_coexist *btcoexist,
134 IN u8 *pprewifi_rssi_state, IN u8 level_num, IN u8 rssi_thresh,
135 IN u8 rssi_thresh1)
136 {
137 s32 wifi_rssi = 0;
138 u8 wifi_rssi_state = *pprewifi_rssi_state;
139
140 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
141
142 if (level_num == 2) {
143 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
144 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
145 if (wifi_rssi >= (rssi_thresh +
146 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
147 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
148 else
149 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
150 } else {
151 if (wifi_rssi < rssi_thresh)
152 wifi_rssi_state = BTC_RSSI_STATE_LOW;
153 else
154 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
155 }
156 } else if (level_num == 3) {
157 if (rssi_thresh > rssi_thresh1) {
158 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
159 "[BTCoex], wifi RSSI thresh error!!\n");
160 BTC_TRACE(trace_buf);
161 return *pprewifi_rssi_state;
162 }
163
164 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
165 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
166 if (wifi_rssi >= (rssi_thresh +
167 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
168 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
169 else
170 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
171 } else if ((*pprewifi_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
172 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
173 if (wifi_rssi >= (rssi_thresh1 +
174 BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
175 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
176 else if (wifi_rssi < rssi_thresh)
177 wifi_rssi_state = BTC_RSSI_STATE_LOW;
178 else
179 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
180 } else {
181 if (wifi_rssi < rssi_thresh1)
182 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
183 else
184 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
185 }
186 }
187
188 *pprewifi_rssi_state = wifi_rssi_state;
189
190 return wifi_rssi_state;
191 }
192
halbtc8723d2ant_coex_switch_threshold(IN struct btc_coexist * btcoexist,IN u8 isolation_measuared)193 void halbtc8723d2ant_coex_switch_threshold(IN struct btc_coexist *btcoexist,
194 IN u8 isolation_measuared)
195 {
196 s8 interference_wl_tx = 0, interference_bt_tx = 0;
197
198
199 interference_wl_tx = BT_8723D_2ANT_WIFI_MAX_TX_POWER -
200 isolation_measuared;
201 interference_bt_tx = BT_8723D_2ANT_BT_MAX_TX_POWER -
202 isolation_measuared;
203
204
205
206 coex_sta->wifi_coex_thres = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1;
207 coex_sta->wifi_coex_thres2 = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES2;
208
209 coex_sta->bt_coex_thres = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1;
210 coex_sta->bt_coex_thres2 = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES2;
211
212
213 /*
214 coex_sta->wifi_coex_thres = interference_wl_tx + BT_8723D_2ANT_WIFI_SIR_THRES1;
215 coex_sta->wifi_coex_thres2 = interference_wl_tx + BT_8723D_2ANT_WIFI_SIR_THRES2;
216
217 coex_sta->bt_coex_thres = interference_bt_tx + BT_8723D_2ANT_BT_SIR_THRES1;
218 coex_sta->bt_coex_thres2 = interference_bt_tx + BT_8723D_2ANT_BT_SIR_THRES2;
219 */
220
221
222
223
224
225 /*
226 if ( BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1 < (isolation_measuared -
227 BT_8723D_2ANT_DEFAULT_ISOLATION) )
228 coex_sta->wifi_coex_thres = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1;
229 else
230 coex_sta->wifi_coex_thres = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1 - (isolation_measuared -
231 BT_8723D_2ANT_DEFAULT_ISOLATION);
232
233 if ( BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1 < (isolation_measuared -
234 BT_8723D_2ANT_DEFAULT_ISOLATION) )
235 coex_sta->bt_coex_thres = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1;
236 else
237 coex_sta->bt_coex_thres = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1 - (isolation_measuared -
238 BT_8723D_2ANT_DEFAULT_ISOLATION);
239
240 */
241 }
242
243
halbtc8723d2ant_limited_rx(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean rej_ap_agg_pkt,IN boolean bt_ctrl_agg_buf_size,IN u8 agg_buf_size)244 void halbtc8723d2ant_limited_rx(IN struct btc_coexist *btcoexist,
245 IN boolean force_exec, IN boolean rej_ap_agg_pkt,
246 IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
247 {
248 boolean reject_rx_agg = rej_ap_agg_pkt;
249 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
250 u8 rx_agg_size = agg_buf_size;
251
252 /* ============================================ */
253 /* Rx Aggregation related setting */
254 /* ============================================ */
255 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
256 &reject_rx_agg);
257 /* decide BT control aggregation buf size or not */
258 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
259 &bt_ctrl_rx_agg_size);
260 /* aggregation buf size, only work when BT control Rx aggregation size. */
261 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
262 /* real update aggregation setting */
263 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
264 }
265
halbtc8723d2ant_query_bt_info(IN struct btc_coexist * btcoexist)266 void halbtc8723d2ant_query_bt_info(IN struct btc_coexist *btcoexist)
267 {
268 u8 h2c_parameter[1] = {0};
269
270
271 h2c_parameter[0] |= BIT(0); /* trigger */
272
273 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
274 }
275
halbtc8723d2ant_monitor_bt_ctr(IN struct btc_coexist * btcoexist)276 void halbtc8723d2ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
277 {
278 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
279 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
280 static u8 num_of_bt_counter_chk = 0, cnt_slave = 0, cnt_overhead = 0,
281 cnt_autoslot_hang = 0;
282
283 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
284
285 reg_hp_txrx = 0x770;
286 reg_lp_txrx = 0x774;
287
288 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
289 reg_hp_tx = u32tmp & MASKLWORD;
290 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
291
292 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
293 reg_lp_tx = u32tmp & MASKLWORD;
294 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
295
296 coex_sta->high_priority_tx = reg_hp_tx;
297 coex_sta->high_priority_rx = reg_hp_rx;
298 coex_sta->low_priority_tx = reg_lp_tx;
299 coex_sta->low_priority_rx = reg_lp_rx;
300
301 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
302 "[BTCoex], Hi-Pri Rx/Tx: %d/%d, Lo-Pri Rx/Tx: %d/%d\n",
303 reg_hp_rx, reg_hp_tx, reg_lp_rx, reg_lp_tx);
304
305 BTC_TRACE(trace_buf);
306
307 if (BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
308 coex_dm->bt_status) {
309
310 if (coex_sta->high_priority_rx >= 15) {
311 if (cnt_overhead < 3)
312 cnt_overhead++;
313
314 if (cnt_overhead == 3)
315 coex_sta->is_hiPri_rx_overhead = TRUE;
316 } else {
317 if (cnt_overhead > 0)
318 cnt_overhead--;
319
320 if (cnt_overhead == 0)
321 coex_sta->is_hiPri_rx_overhead = FALSE;
322 }
323 } else
324 coex_sta->is_hiPri_rx_overhead = FALSE;
325
326 /* reset counter */
327 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
328
329 if ((coex_sta->low_priority_tx > 1050) &&
330 (!coex_sta->c2h_bt_inquiry_page))
331 coex_sta->pop_event_cnt++;
332
333 if ((coex_sta->low_priority_rx >= 950) &&
334 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx)
335 && (!coex_sta->under_ips) && (!coex_sta->c2h_bt_inquiry_page) &&
336 (coex_sta->bt_link_exist)) {
337 if (cnt_slave >= 2) {
338 bt_link_info->slave_role = TRUE;
339 cnt_slave = 2;
340 } else
341 cnt_slave++;
342 } else {
343 if (cnt_slave == 0) {
344 bt_link_info->slave_role = FALSE;
345 cnt_slave = 0;
346 } else
347 cnt_slave--;
348
349 }
350
351 if (coex_sta->is_tdma_btautoslot) {
352 if ((coex_sta->low_priority_tx >= 1300) &&
353 (coex_sta->low_priority_rx <= 150)) {
354 if (cnt_autoslot_hang >= 2) {
355 coex_sta->is_tdma_btautoslot_hang = TRUE;
356 cnt_autoslot_hang = 2;
357 } else
358 cnt_autoslot_hang++;
359 } else {
360 if (cnt_autoslot_hang == 0) {
361 coex_sta->is_tdma_btautoslot_hang = FALSE;
362 cnt_autoslot_hang = 0;
363 } else
364 cnt_autoslot_hang--;
365 }
366 }
367
368 if (coex_sta->sco_exist) {
369 if ((coex_sta->high_priority_tx >= 400) &&
370 (coex_sta->high_priority_rx >= 400))
371 coex_sta->is_eSCO_mode = FALSE;
372 else
373 coex_sta->is_eSCO_mode = TRUE;
374 }
375
376 if (bt_link_info->hid_only) {
377 if (coex_sta->low_priority_rx > 50)
378 coex_sta->is_hid_low_pri_tx_overhead = true;
379 else
380 coex_sta->is_hid_low_pri_tx_overhead = false;
381 }
382
383 if (!coex_sta->bt_disabled) {
384
385 if ((coex_sta->high_priority_tx == 0) &&
386 (coex_sta->high_priority_rx == 0) &&
387 (coex_sta->low_priority_tx == 0) &&
388 (coex_sta->low_priority_rx == 0)) {
389 num_of_bt_counter_chk++;
390 if (num_of_bt_counter_chk >= 3) {
391 halbtc8723d2ant_query_bt_info(btcoexist);
392 num_of_bt_counter_chk = 0;
393 }
394 }
395 }
396
397 }
398
halbtc8723d2ant_monitor_wifi_ctr(IN struct btc_coexist * btcoexist)399 void halbtc8723d2ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
400 {
401 s32 wifi_rssi = 0;
402 boolean wifi_busy = FALSE, wifi_under_b_mode = FALSE,
403 wifi_scan = FALSE, wifi_connected = FALSE;
404 boolean bt_idle = FALSE, wl_idle = FALSE, is_cck_deadlock = FALSE;
405 static u8 cck_lock_counter = 0, wl_noisy_count0 = 0,
406 wl_noisy_count1 = 3, wl_noisy_count2 = 0;
407 u32 total_cnt, reg_val1, reg_val2, cnt_cck;
408 u32 cnt_crcok = 0, cnt_crcerr = 0, cnt_ccklocking = 0;
409 static u8 cnt = 0, cnt_cal = 0;
410 u8 h2c_parameter[1] = {0};
411 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
412
413 /*send h2c to query WL FW dbg info */
414 if (((coex_dm->cur_ps_tdma_on) && (coex_sta->force_lps_ctrl)) ||
415 ((coex_sta->acl_busy) && (bt_link_info->a2dp_exist))) {
416 h2c_parameter[0] = 0x8;
417 btcoexist->btc_fill_h2c(btcoexist, 0x69, 1, h2c_parameter);
418 }
419
420 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
421 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
422 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
423 &wifi_under_b_mode);
424
425 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
426
427 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_PHY_counter(
428 btcoexist,
429 PHYDM_INFO_CRC32_OK_CCK);
430 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_PHY_counter(
431 btcoexist,
432 PHYDM_INFO_CRC32_OK_LEGACY);
433 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_PHY_counter(
434 btcoexist,
435 PHYDM_INFO_CRC32_OK_HT);
436 coex_sta->crc_ok_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
437 btcoexist,
438 PHYDM_INFO_CRC32_OK_VHT);
439
440 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_PHY_counter(
441 btcoexist, PHYDM_INFO_CRC32_ERROR_CCK);
442 coex_sta->crc_err_11g = btcoexist->btc_phydm_query_PHY_counter(
443 btcoexist, PHYDM_INFO_CRC32_ERROR_LEGACY);
444 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_PHY_counter(
445 btcoexist, PHYDM_INFO_CRC32_ERROR_HT);
446 coex_sta->crc_err_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
447 btcoexist,
448 PHYDM_INFO_CRC32_ERROR_VHT);
449
450 cnt_crcok = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g
451 + coex_sta->crc_ok_11n
452 + coex_sta->crc_ok_11n_vht;
453
454 cnt_crcerr = coex_sta->crc_err_cck + coex_sta->crc_err_11g
455 + coex_sta->crc_err_11n
456 + coex_sta->crc_err_11n_vht;
457
458
459 if ((wifi_busy) && (cnt_crcerr != 0)) {
460 if (cnt_cal == 0)
461 coex_sta->cnt_crcok_max_in_10s = 0;
462
463 cnt_cal++;
464
465 if (cnt_crcok > coex_sta->cnt_crcok_max_in_10s)
466 coex_sta->cnt_crcok_max_in_10s = cnt_crcok;
467
468 if (cnt_cal == 5)
469 cnt_cal = 0;
470
471 coex_sta->now_crc_ratio = cnt_crcok/cnt_crcerr;
472
473 if (cnt == 0)
474 coex_sta->acc_crc_ratio = coex_sta->now_crc_ratio;
475 else
476 coex_sta->acc_crc_ratio = (coex_sta->acc_crc_ratio * 7 +
477 coex_sta->now_crc_ratio * 3)/10;
478
479 if (cnt >= 10)
480 cnt = 0;
481 else
482 cnt++;
483 }
484
485 /* CCK lock identification */
486 if (coex_sta->cck_lock)
487 cnt_ccklocking++;
488 else if (cnt_ccklocking != 0)
489 cnt_ccklocking--;
490
491 if (cnt_ccklocking >= 3) {
492 cnt_ccklocking = 3;
493 coex_sta->cck_lock_ever = TRUE;
494 }
495
496 /* WiFi environment noisy identification */
497 cnt_cck = coex_sta->crc_ok_cck + coex_sta->crc_err_cck;
498
499 if ((!wifi_busy) && (!coex_sta->cck_lock)) {
500 if (cnt_cck > 250) {
501 if (wl_noisy_count2 < 3)
502 wl_noisy_count2++;
503
504 if (wl_noisy_count2 == 3) {
505 wl_noisy_count0 = 0;
506 wl_noisy_count1 = 0;
507 }
508
509 } else if (cnt_cck < 50) {
510 if (wl_noisy_count0 < 3)
511 wl_noisy_count0++;
512
513 if (wl_noisy_count0 == 3) {
514 wl_noisy_count1 = 0;
515 wl_noisy_count2 = 0;
516 }
517
518 } else {
519 if (wl_noisy_count1 < 3)
520 wl_noisy_count1++;
521
522 if (wl_noisy_count1 == 3) {
523 wl_noisy_count0 = 0;
524 wl_noisy_count2 = 0;
525 }
526 }
527
528 if (wl_noisy_count2 == 3)
529 coex_sta->wl_noisy_level = 2;
530 else if (wl_noisy_count1 == 3)
531 coex_sta->wl_noisy_level = 1;
532 else
533 coex_sta->wl_noisy_level = 0;
534 }
535 }
536
537
538
halbtc8723d2ant_update_bt_link_info(IN struct btc_coexist * btcoexist)539 void halbtc8723d2ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
540 {
541 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
542 boolean bt_hs_on = FALSE;
543 boolean bt_busy = FALSE;
544
545
546 coex_sta->num_of_profile = 0;
547
548 /* set link exist status */
549 if (!(coex_sta->bt_info & BT_INFO_8723D_2ANT_B_CONNECTION)) {
550 coex_sta->bt_link_exist = FALSE;
551 coex_sta->pan_exist = FALSE;
552 coex_sta->a2dp_exist = FALSE;
553 coex_sta->hid_exist = FALSE;
554 coex_sta->sco_exist = FALSE;
555 } else { /* connection exists */
556 coex_sta->bt_link_exist = TRUE;
557 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_FTP) {
558 coex_sta->pan_exist = TRUE;
559 coex_sta->num_of_profile++;
560 } else
561 coex_sta->pan_exist = FALSE;
562
563 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_A2DP) {
564 coex_sta->a2dp_exist = TRUE;
565 coex_sta->num_of_profile++;
566 } else
567 coex_sta->a2dp_exist = FALSE;
568
569 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_HID) {
570 coex_sta->hid_exist = TRUE;
571 coex_sta->num_of_profile++;
572 } else
573 coex_sta->hid_exist = FALSE;
574
575 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) {
576 coex_sta->sco_exist = TRUE;
577 coex_sta->num_of_profile++;
578 } else
579 coex_sta->sco_exist = FALSE;
580
581 }
582
583 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
584
585 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
586 bt_link_info->sco_exist = coex_sta->sco_exist;
587 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
588 bt_link_info->pan_exist = coex_sta->pan_exist;
589 bt_link_info->hid_exist = coex_sta->hid_exist;
590 bt_link_info->acl_busy = coex_sta->acl_busy;
591
592 /* work around for HS mode. */
593 if (bt_hs_on) {
594 bt_link_info->pan_exist = TRUE;
595 bt_link_info->bt_link_exist = TRUE;
596 }
597
598 /* check if Sco only */
599 if (bt_link_info->sco_exist &&
600 !bt_link_info->a2dp_exist &&
601 !bt_link_info->pan_exist &&
602 !bt_link_info->hid_exist)
603 bt_link_info->sco_only = TRUE;
604 else
605 bt_link_info->sco_only = FALSE;
606
607 /* check if A2dp only */
608 if (!bt_link_info->sco_exist &&
609 bt_link_info->a2dp_exist &&
610 !bt_link_info->pan_exist &&
611 !bt_link_info->hid_exist)
612 bt_link_info->a2dp_only = TRUE;
613 else
614 bt_link_info->a2dp_only = FALSE;
615
616 /* check if Pan only */
617 if (!bt_link_info->sco_exist &&
618 !bt_link_info->a2dp_exist &&
619 bt_link_info->pan_exist &&
620 !bt_link_info->hid_exist)
621 bt_link_info->pan_only = TRUE;
622 else
623 bt_link_info->pan_only = FALSE;
624
625 /* check if Hid only */
626 if (!bt_link_info->sco_exist &&
627 !bt_link_info->a2dp_exist &&
628 !bt_link_info->pan_exist &&
629 bt_link_info->hid_exist)
630 bt_link_info->hid_only = TRUE;
631 else
632 bt_link_info->hid_only = FALSE;
633
634 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_INQ_PAGE) {
635 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_INQ_PAGE;
636 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
637 "[BTCoex], BtInfoNotify(), BT Inq/page!!!\n");
638 } else if (!(coex_sta->bt_info & BT_INFO_8723D_2ANT_B_CONNECTION)) {
639 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
640 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
641 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
642 } else if (coex_sta->bt_info == BT_INFO_8723D_2ANT_B_CONNECTION) {
643 /* connection exists but no busy */
644 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE;
645 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
646 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
647 } else if (((coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) ||
648 (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_BUSY)) &&
649 (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_ACL_BUSY)) {
650 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY;
651 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
652 "[BTCoex], BtInfoNotify(), BT ACL SCO busy!!!\n");
653 } else if ((coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) ||
654 (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_BUSY)) {
655 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_SCO_BUSY;
656 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
657 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
658 } else if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_ACL_BUSY) {
659 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_ACL_BUSY;
660 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
661 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
662 } else {
663 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_MAX;
664 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
665 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
666 }
667
668 BTC_TRACE(trace_buf);
669
670 if ((BT_8723D_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
671 (BT_8723D_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
672 (BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
673 bt_busy = TRUE;
674 else
675 bt_busy = FALSE;
676
677 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
678 }
679
halbtc8723d2ant_update_wifi_channel_info(IN struct btc_coexist * btcoexist,IN u8 type)680 void halbtc8723d2ant_update_wifi_channel_info(IN struct btc_coexist *btcoexist,
681 IN u8 type)
682 {
683 u8 h2c_parameter[3] = {0};
684 u32 wifi_bw;
685 u8 wifi_central_chnl;
686
687 /* only 2.4G we need to inform bt the chnl mask */
688 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
689 &wifi_central_chnl);
690 if ((BTC_MEDIA_CONNECT == type) &&
691 (wifi_central_chnl <= 14)) {
692 h2c_parameter[0] =
693 0x1; /* enable BT AFH skip WL channel for 8723d because BT Rx LO interference */
694 /* h2c_parameter[0] = 0x0; */
695 h2c_parameter[1] = wifi_central_chnl;
696 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
697 if (BTC_WIFI_BW_HT40 == wifi_bw)
698 h2c_parameter[2] = 0x30;
699 else
700 h2c_parameter[2] = 0x20;
701 }
702
703 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
704 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
705 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
706
707 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
708
709 }
710
halbtc8723d2ant_set_fw_dac_swing_level(IN struct btc_coexist * btcoexist,IN u8 dac_swing_lvl)711 void halbtc8723d2ant_set_fw_dac_swing_level(IN struct btc_coexist *btcoexist,
712 IN u8 dac_swing_lvl)
713 {
714 u8 h2c_parameter[1] = {0};
715
716 /* There are several type of dacswing */
717 /* 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
718 h2c_parameter[0] = dac_swing_lvl;
719
720 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
721 }
722
halbtc8723d2ant_fw_dac_swing_lvl(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 fw_dac_swing_lvl)723 void halbtc8723d2ant_fw_dac_swing_lvl(IN struct btc_coexist *btcoexist,
724 IN boolean force_exec, IN u8 fw_dac_swing_lvl)
725 {
726 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
727
728 if (!force_exec) {
729 if (coex_dm->pre_fw_dac_swing_lvl ==
730 coex_dm->cur_fw_dac_swing_lvl)
731 return;
732 }
733
734 halbtc8723d2ant_set_fw_dac_swing_level(btcoexist,
735 coex_dm->cur_fw_dac_swing_lvl);
736
737 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
738 }
739
halbtc8723d2ant_set_fw_dec_bt_pwr(IN struct btc_coexist * btcoexist,IN u8 dec_bt_pwr_lvl)740 void halbtc8723d2ant_set_fw_dec_bt_pwr(IN struct btc_coexist *btcoexist,
741 IN u8 dec_bt_pwr_lvl)
742 {
743 u8 h2c_parameter[1] = {0};
744
745 h2c_parameter[0] = 0 - dec_bt_pwr_lvl;
746
747 #if 0
748 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
749 #endif
750 }
751
halbtc8723d2ant_dec_bt_pwr(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 dec_bt_pwr_lvl)752 void halbtc8723d2ant_dec_bt_pwr(IN struct btc_coexist *btcoexist,
753 IN boolean force_exec, IN u8 dec_bt_pwr_lvl)
754 {
755 coex_dm->cur_bt_dec_pwr_lvl = dec_bt_pwr_lvl;
756
757 if (!force_exec) {
758 if (coex_dm->pre_bt_dec_pwr_lvl == coex_dm->cur_bt_dec_pwr_lvl)
759 return;
760 }
761 halbtc8723d2ant_set_fw_dec_bt_pwr(btcoexist,
762 coex_dm->cur_bt_dec_pwr_lvl);
763
764 coex_dm->pre_bt_dec_pwr_lvl = coex_dm->cur_bt_dec_pwr_lvl;
765 }
766
halbtc8723d2ant_set_fw_low_penalty_ra(IN struct btc_coexist * btcoexist,IN boolean low_penalty_ra)767 void halbtc8723d2ant_set_fw_low_penalty_ra(IN struct btc_coexist
768 *btcoexist, IN boolean low_penalty_ra)
769 {
770 #if 1
771 u8 h2c_parameter[6] = {0};
772
773 h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
774
775 if (low_penalty_ra) {
776 h2c_parameter[1] |= BIT(0);
777 h2c_parameter[2] =
778 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
779 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
780 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
781 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
782 }
783
784 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
785 #endif
786 }
787
halbtc8723d2ant_low_penalty_ra(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean low_penalty_ra)788 void halbtc8723d2ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
789 IN boolean force_exec, IN boolean low_penalty_ra)
790 {
791 #if 1
792 coex_dm->cur_low_penalty_ra = low_penalty_ra;
793
794 if (!force_exec) {
795 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
796 return;
797 }
798
799 halbtc8723d2ant_set_fw_low_penalty_ra(btcoexist,
800 coex_dm->cur_low_penalty_ra);
801
802 #if 0
803 if (low_penalty_ra)
804 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 15);
805 else
806 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 0);
807 #endif
808 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
809
810 #endif
811 }
812
halbtc8723d2ant_set_bt_auto_report(IN struct btc_coexist * btcoexist,IN boolean enable_auto_report)813 void halbtc8723d2ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
814 IN boolean enable_auto_report)
815 {
816 u8 h2c_parameter[1] = {0};
817
818 h2c_parameter[0] = 0;
819
820 if (enable_auto_report)
821 h2c_parameter[0] |= BIT(0);
822
823 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
824 }
825
halbtc8723d2ant_bt_auto_report(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean enable_auto_report)826 void halbtc8723d2ant_bt_auto_report(IN struct btc_coexist *btcoexist,
827 IN boolean force_exec, IN boolean enable_auto_report)
828 {
829 coex_dm->cur_bt_auto_report = enable_auto_report;
830
831 if (!force_exec) {
832 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
833 return;
834 }
835 halbtc8723d2ant_set_bt_auto_report(btcoexist,
836 coex_dm->cur_bt_auto_report);
837
838 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
839 }
840
halbtc8723d2ant_write_score_board(IN struct btc_coexist * btcoexist,IN u16 bitpos,IN boolean state)841 void halbtc8723d2ant_write_score_board(
842 IN struct btc_coexist *btcoexist,
843 IN u16 bitpos,
844 IN boolean state
845 )
846 {
847
848 static u16 originalval = 0x8002, preval = 0x0;
849
850 if (state)
851 originalval = originalval | bitpos;
852 else
853 originalval = originalval & (~bitpos);
854
855 coex_sta->score_board_WB = originalval;
856
857 if (originalval != preval) {
858
859 preval = originalval;
860 btcoexist->btc_write_2byte(btcoexist, 0xaa, originalval);
861 } else {
862 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
863 "[BTCoex], halbtc8723d2ant_write_score_board: return for nochange\n");
864 BTC_TRACE(trace_buf);
865 }
866 }
867
868
869
halbtc8723d2ant_read_score_board(IN struct btc_coexist * btcoexist,IN u16 * score_board_val)870 void halbtc8723d2ant_read_score_board(
871 IN struct btc_coexist *btcoexist,
872 IN u16 *score_board_val
873 )
874 {
875
876 *score_board_val = (btcoexist->btc_read_2byte(btcoexist,
877 0xaa)) & 0x7fff;
878 }
879
880
halbtc8723d2ant_post_state_to_bt(IN struct btc_coexist * btcoexist,IN u16 type,IN boolean state)881 void halbtc8723d2ant_post_state_to_bt(
882 IN struct btc_coexist *btcoexist,
883 IN u16 type,
884 IN boolean state
885 )
886 {
887 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
888 "[BTCoex], halbtc8723d2ant_post_state_to_bt: type = %d, state =%d\n",
889 type, state);
890 BTC_TRACE(trace_buf);
891
892 halbtc8723d2ant_write_score_board(btcoexist, (u16) type, state);
893
894 }
895
halbtc8723d2ant_is_wifibt_status_changed(IN struct btc_coexist * btcoexist)896 boolean halbtc8723d2ant_is_wifibt_status_changed(IN struct btc_coexist
897 *btcoexist)
898 {
899 static boolean pre_wifi_busy = FALSE, pre_under_4way = FALSE,
900 pre_bt_hs_on = FALSE, pre_bt_off = FALSE,
901 pre_bt_slave = FALSE, pre_hid_low_pri_tx_overhead = FALSE,
902 pre_wifi_under_lps = FALSE, pre_bt_setup_link = FALSE,
903 pre_cck_lock = FALSE, pre_cck_lock_warn = FALSE;
904 static u8 pre_hid_busy_num = 0, pre_wl_noisy_level = 0;
905 boolean wifi_busy = FALSE, under_4way = FALSE, bt_hs_on = FALSE;
906 boolean wifi_connected = FALSE;
907 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
908
909 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
910 &wifi_connected);
911 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
912 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
913 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
914 &under_4way);
915
916 if (coex_sta->bt_disabled != pre_bt_off) {
917 pre_bt_off = coex_sta->bt_disabled;
918
919 if (coex_sta->bt_disabled)
920 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
921 "[BTCoex], BT is disabled !!\n");
922 else
923 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
924 "[BTCoex], BT is enabled !!\n");
925
926 BTC_TRACE(trace_buf);
927
928 coex_sta->bt_coex_supported_feature = 0;
929 coex_sta->bt_coex_supported_version = 0;
930 coex_sta->bt_ble_scan_type = 0;
931 coex_sta->bt_ble_scan_para[0] = 0;
932 coex_sta->bt_ble_scan_para[1] = 0;
933 coex_sta->bt_ble_scan_para[2] = 0;
934 coex_sta->bt_reg_vendor_ac = 0xffff;
935 coex_sta->bt_reg_vendor_ae = 0xffff;
936 return TRUE;
937 }
938
939 if (wifi_connected) {
940 if (wifi_busy != pre_wifi_busy) {
941 pre_wifi_busy = wifi_busy;
942
943 if (wifi_busy)
944 halbtc8723d2ant_post_state_to_bt(btcoexist,
945 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, TRUE);
946 else
947 halbtc8723d2ant_post_state_to_bt(btcoexist,
948 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, FALSE);
949 return TRUE;
950 }
951 if (under_4way != pre_under_4way) {
952 pre_under_4way = under_4way;
953 return TRUE;
954 }
955 if (bt_hs_on != pre_bt_hs_on) {
956 pre_bt_hs_on = bt_hs_on;
957 return TRUE;
958 }
959 if (coex_sta->wl_noisy_level != pre_wl_noisy_level) {
960 pre_wl_noisy_level = coex_sta->wl_noisy_level;
961 return TRUE;
962 }
963 if (coex_sta->under_lps != pre_wifi_under_lps) {
964 pre_wifi_under_lps = coex_sta->under_lps;
965 if (coex_sta->under_lps == TRUE)
966 return TRUE;
967 }
968 if (coex_sta->cck_lock != pre_cck_lock) {
969 pre_cck_lock = coex_sta->cck_lock;
970 return TRUE;
971 }
972 if (coex_sta->cck_lock_warn != pre_cck_lock_warn) {
973 pre_cck_lock_warn = coex_sta->cck_lock_warn;
974 return TRUE;
975 }
976 }
977
978 if (!coex_sta->bt_disabled) {
979 if (coex_sta->hid_busy_num != pre_hid_busy_num) {
980 pre_hid_busy_num = coex_sta->hid_busy_num;
981 return TRUE;
982 }
983
984 if (bt_link_info->slave_role != pre_bt_slave) {
985 pre_bt_slave = bt_link_info->slave_role;
986 return TRUE;
987 }
988
989 if (pre_hid_low_pri_tx_overhead != coex_sta->is_hid_low_pri_tx_overhead) {
990 pre_hid_low_pri_tx_overhead = coex_sta->is_hid_low_pri_tx_overhead;
991 return TRUE;
992 }
993
994 if (pre_bt_setup_link != coex_sta->is_setupLink) {
995 pre_bt_setup_link = coex_sta->is_setupLink;
996 return TRUE;
997 }
998 }
999
1000 return FALSE;
1001 }
1002
halbtc8723d2ant_monitor_bt_enable_disable(IN struct btc_coexist * btcoexist)1003 void halbtc8723d2ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
1004 {
1005 static u32 bt_disable_cnt = 0;
1006 boolean bt_active = TRUE, bt_disabled = FALSE;
1007 u16 u16tmp;
1008
1009 /* This function check if bt is disabled */
1010 #if 0
1011 if (coex_sta->high_priority_tx == 0 &&
1012 coex_sta->high_priority_rx == 0 &&
1013 coex_sta->low_priority_tx == 0 &&
1014 coex_sta->low_priority_rx == 0)
1015 bt_active = FALSE;
1016 if (coex_sta->high_priority_tx == 0xffff &&
1017 coex_sta->high_priority_rx == 0xffff &&
1018 coex_sta->low_priority_tx == 0xffff &&
1019 coex_sta->low_priority_rx == 0xffff)
1020 bt_active = FALSE;
1021
1022
1023 #else
1024
1025 /* Read BT on/off status from scoreboard[1], enable this only if BT patch support this feature */
1026 halbtc8723d2ant_read_score_board(btcoexist, &u16tmp);
1027
1028 bt_active = u16tmp & BIT(1);
1029
1030
1031 #endif
1032
1033 if (bt_active) {
1034 bt_disable_cnt = 0;
1035 bt_disabled = FALSE;
1036 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1037 &bt_disabled);
1038 } else {
1039
1040 bt_disable_cnt++;
1041 if (bt_disable_cnt >= 2) {
1042 bt_disabled = TRUE;
1043 bt_disable_cnt = 2;
1044 }
1045
1046 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1047 &bt_disabled);
1048 }
1049
1050 if (bt_disabled)
1051 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, FALSE);
1052 else
1053 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, TRUE);
1054
1055 if (coex_sta->bt_disabled != bt_disabled) {
1056 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1057 "[BTCoex], BT is from %s to %s!!\n",
1058 (coex_sta->bt_disabled ? "disabled" : "enabled"),
1059 (bt_disabled ? "disabled" : "enabled"));
1060 BTC_TRACE(trace_buf);
1061 coex_sta->bt_disabled = bt_disabled;
1062 }
1063
1064 }
1065
1066
1067
halbtc8723d2ant_enable_gnt_to_gpio(IN struct btc_coexist * btcoexist,boolean isenable)1068 void halbtc8723d2ant_enable_gnt_to_gpio(IN struct btc_coexist *btcoexist,
1069 boolean isenable)
1070 {
1071 #if BT_8723D_2ANT_COEX_DBG
1072 if (isenable) {
1073 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x1);
1074
1075 /* enable GNT_BT to GPIO debug */
1076 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x0);
1077 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x0);
1078
1079 /* 0x48[20] = 0 for GPIO14 = GNT_WL*/
1080 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4a, 0x10, 0x0);
1081 /* 0x40[17] = 0 for GPIO14 = GNT_WL*/
1082 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x42, 0x02, 0x0);
1083
1084 /* 0x66[9] = 0 for GPIO15 = GNT_BT*/
1085 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x02, 0x0);
1086 /* 0x66[7] = 0
1087 for GPIO15 = GNT_BT*/
1088 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x66, 0x80, 0x0);
1089 /* 0x8[8] = 0 for GPIO15 = GNT_BT*/
1090 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x9, 0x1, 0x0);
1091
1092 /* BT Vendor Reg 0x76[0] = 0 for GPIO15 = GNT_BT, this is not set here*/
1093 } else {
1094 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x0);
1095
1096 /* Disable GNT_BT debug to GPIO, and enable chip_wakeup_host */
1097 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x1);
1098 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x1);
1099
1100 /* 0x48[20] = 0 for GPIO14 = GNT_WL*/
1101 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4a, 0x10, 0x1);
1102 }
1103
1104 #endif
1105 }
1106
halbtc8723d2ant_ltecoex_indirect_read_reg(IN struct btc_coexist * btcoexist,IN u16 reg_addr)1107 u32 halbtc8723d2ant_ltecoex_indirect_read_reg(IN struct btc_coexist *btcoexist,
1108 IN u16 reg_addr)
1109 {
1110 u32 j = 0, delay_count = 0;
1111
1112 /* wait for ready bit before access 0x7c0/0x7c4 */
1113 while (1) {
1114 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3)&BIT(5)) == 0) {
1115 delay_ms(50);
1116 delay_count++;
1117 if (delay_count >= 10) {
1118 delay_count = 0;
1119 break;
1120 }
1121 } else
1122 break;
1123 }
1124
1125 btcoexist->btc_write_4byte(btcoexist, 0x7c0, 0x800F0000 | reg_addr);
1126
1127 return btcoexist->btc_read_4byte(btcoexist,
1128 0x7c8); /* get read data */
1129
1130 }
1131
halbtc8723d2ant_ltecoex_indirect_write_reg(IN struct btc_coexist * btcoexist,IN u16 reg_addr,IN u32 bit_mask,IN u32 reg_value)1132 void halbtc8723d2ant_ltecoex_indirect_write_reg(IN struct btc_coexist
1133 *btcoexist,
1134 IN u16 reg_addr, IN u32 bit_mask, IN u32 reg_value)
1135 {
1136 u32 val, i = 0, j = 0, bitpos = 0, delay_count = 0;
1137
1138
1139 if (bit_mask == 0x0)
1140 return;
1141 if (bit_mask == 0xffffffff) {
1142 /* wait for ready bit before access 0x7c0/0x7c4 */
1143 while (1) {
1144 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3)&BIT(5)) == 0) {
1145 delay_ms(50);
1146 delay_count++;
1147 if (delay_count >= 10) {
1148 delay_count = 0;
1149 break;
1150 }
1151 } else
1152 break;
1153 }
1154
1155 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1156 reg_value); /* put write data */
1157
1158 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1159 0xc00F0000 | reg_addr);
1160 } else {
1161 for (i = 0; i <= 31; i++) {
1162 if (((bit_mask >> i) & 0x1) == 0x1) {
1163 bitpos = i;
1164 break;
1165 }
1166 }
1167
1168 /* read back register value before write */
1169 val = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1170 reg_addr);
1171 val = (val & (~bit_mask)) | (reg_value << bitpos);
1172
1173 /* wait for ready bit before access 0x7c0/0x7c4 */
1174 while (1) {
1175 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3)&BIT(5)) == 0) {
1176 delay_ms(50);
1177 delay_count++;
1178 if (delay_count >= 10) {
1179 delay_count = 0;
1180 break;
1181 }
1182 } else
1183 break;
1184 }
1185
1186 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1187 val); /* put write data */
1188
1189 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1190 0xc00F0000 | reg_addr);
1191
1192 }
1193
1194 }
1195
halbtc8723d2ant_ltecoex_enable(IN struct btc_coexist * btcoexist,IN boolean enable)1196 void halbtc8723d2ant_ltecoex_enable(IN struct btc_coexist *btcoexist,
1197 IN boolean enable)
1198 {
1199 u8 val;
1200
1201 val = (enable) ? 1 : 0;
1202 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, 0x38, 0x80,
1203 val); /* 0x38[7] */
1204
1205 }
1206
halbtc8723d2ant_ltecoex_pathcontrol_owner(IN struct btc_coexist * btcoexist,IN boolean wifi_control)1207 void halbtc8723d2ant_ltecoex_pathcontrol_owner(IN struct btc_coexist *btcoexist,
1208 IN boolean wifi_control)
1209 {
1210 u8 val;
1211
1212 val = (wifi_control) ? 1 : 0;
1213 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x4,
1214 val); /* 0x70[26] */
1215
1216 }
1217
halbtc8723d2ant_ltecoex_set_gnt_bt(IN struct btc_coexist * btcoexist,IN u8 control_block,IN boolean sw_control,IN u8 state)1218 void halbtc8723d2ant_ltecoex_set_gnt_bt(IN struct btc_coexist *btcoexist,
1219 IN u8 control_block, IN boolean sw_control, IN u8 state)
1220 {
1221 u32 val = 0, val_orig = 0;
1222
1223 if (!sw_control)
1224 val = 0x0;
1225 else if (state & 0x1)
1226 val = 0x3;
1227 else
1228 val = 0x1;
1229
1230 val_orig = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1231 0x38);
1232
1233 switch (control_block) {
1234 case BT_8723D_2ANT_GNT_BLOCK_RFC_BB:
1235 default:
1236 val = ((val << 14) | (val << 10)) | (val_orig & 0xffff33ff);
1237 break;
1238 case BT_8723D_2ANT_GNT_BLOCK_RFC:
1239 val = (val << 14) | (val_orig & 0xffff3fff);
1240 break;
1241 case BT_8723D_2ANT_GNT_BLOCK_BB:
1242 val = (val << 10) | (val_orig & 0xfffff3ff);
1243 break;
1244 }
1245
1246 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist,
1247 0x38, 0xffffffff, val);
1248 }
1249
1250
halbtc8723d2ant_ltecoex_set_gnt_wl(IN struct btc_coexist * btcoexist,IN u8 control_block,IN boolean sw_control,IN u8 state)1251 void halbtc8723d2ant_ltecoex_set_gnt_wl(IN struct btc_coexist *btcoexist,
1252 IN u8 control_block, IN boolean sw_control, IN u8 state)
1253 {
1254 u32 val = 0, val_orig = 0;
1255
1256 if (!sw_control)
1257 val = 0x0;
1258 else if (state & 0x1)
1259 val = 0x3;
1260 else
1261 val = 0x1;
1262
1263 val_orig = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1264 0x38);
1265
1266 switch (control_block) {
1267 case BT_8723D_2ANT_GNT_BLOCK_RFC_BB:
1268 default:
1269 val = ((val << 12) | (val << 8)) | (val_orig & 0xffffccff);
1270 break;
1271 case BT_8723D_2ANT_GNT_BLOCK_RFC:
1272 val = (val << 12) | (val_orig & 0xffffcfff);
1273 break;
1274 case BT_8723D_2ANT_GNT_BLOCK_BB:
1275 val = (val << 8) | (val_orig & 0xfffffcff);
1276 break;
1277 }
1278
1279 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist,
1280 0x38, 0xffffffff, val);
1281 }
1282
halbtc8723d2ant_ltecoex_set_coex_table(IN struct btc_coexist * btcoexist,IN u8 table_type,IN u16 table_content)1283 void halbtc8723d2ant_ltecoex_set_coex_table(IN struct btc_coexist *btcoexist,
1284 IN u8 table_type, IN u16 table_content)
1285 {
1286 u16 reg_addr = 0x0000;
1287
1288 switch (table_type) {
1289 case BT_8723D_2ANT_CTT_WL_VS_LTE:
1290 reg_addr = 0xa0;
1291 break;
1292 case BT_8723D_2ANT_CTT_BT_VS_LTE:
1293 reg_addr = 0xa4;
1294 break;
1295 }
1296
1297 if (reg_addr != 0x0000)
1298 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1299 0xffff, table_content); /* 0xa0[15:0] or 0xa4[15:0] */
1300
1301
1302 }
1303
1304
halbtc8723d2ant_ltecoex_set_break_table(IN struct btc_coexist * btcoexist,IN u8 table_type,IN u8 table_content)1305 void halbtc8723d2ant_ltecoex_set_break_table(IN struct btc_coexist *btcoexist,
1306 IN u8 table_type, IN u8 table_content)
1307 {
1308 u16 reg_addr = 0x0000;
1309
1310 switch (table_type) {
1311 case BT_8723D_2ANT_LBTT_WL_BREAK_LTE:
1312 reg_addr = 0xa8;
1313 break;
1314 case BT_8723D_2ANT_LBTT_BT_BREAK_LTE:
1315 reg_addr = 0xac;
1316 break;
1317 case BT_8723D_2ANT_LBTT_LTE_BREAK_WL:
1318 reg_addr = 0xb0;
1319 break;
1320 case BT_8723D_2ANT_LBTT_LTE_BREAK_BT:
1321 reg_addr = 0xb4;
1322 break;
1323 }
1324
1325 if (reg_addr != 0x0000)
1326 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1327 0xff, table_content); /* 0xa8[15:0] or 0xb4[15:0] */
1328
1329
1330 }
1331
halbtc8723d2ant_set_wltoggle_coex_table(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 interval,IN u8 val0x6c4_b0,IN u8 val0x6c4_b1,IN u8 val0x6c4_b2,IN u8 val0x6c4_b3)1332 void halbtc8723d2ant_set_wltoggle_coex_table(IN struct btc_coexist *btcoexist,
1333 IN boolean force_exec, IN u8 interval,
1334 IN u8 val0x6c4_b0, IN u8 val0x6c4_b1, IN u8 val0x6c4_b2,
1335 IN u8 val0x6c4_b3)
1336 {
1337 static u8 pre_h2c_parameter[6] = {0};
1338 u8 cur_h2c_parameter[6] = {0};
1339 u8 i, match_cnt = 0;
1340
1341 cur_h2c_parameter[0] = 0x7; /* op_code, 0x7= wlan toggle slot*/
1342
1343 cur_h2c_parameter[1] = interval;
1344 cur_h2c_parameter[2] = val0x6c4_b0;
1345 cur_h2c_parameter[3] = val0x6c4_b1;
1346 cur_h2c_parameter[4] = val0x6c4_b2;
1347 cur_h2c_parameter[5] = val0x6c4_b3;
1348
1349 if (!force_exec) {
1350 for (i = 1; i <= 5; i++) {
1351 if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
1352 break;
1353
1354 match_cnt++;
1355 }
1356
1357 if (match_cnt == 5)
1358 return;
1359 }
1360
1361 for (i = 1; i <= 5; i++)
1362 pre_h2c_parameter[i] = cur_h2c_parameter[i];
1363
1364 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, cur_h2c_parameter);
1365 }
1366
halbtc8723d2ant_set_coex_table(IN struct btc_coexist * btcoexist,IN u32 val0x6c0,IN u32 val0x6c4,IN u32 val0x6c8,IN u8 val0x6cc)1367 void halbtc8723d2ant_set_coex_table(IN struct btc_coexist *btcoexist,
1368 IN u32 val0x6c0, IN u32 val0x6c4, IN u32 val0x6c8, IN u8 val0x6cc)
1369 {
1370 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
1371
1372 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
1373
1374 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
1375
1376 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
1377 }
1378
halbtc8723d2ant_coex_table(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u32 val0x6c0,IN u32 val0x6c4,IN u32 val0x6c8,IN u8 val0x6cc)1379 void halbtc8723d2ant_coex_table(IN struct btc_coexist *btcoexist,
1380 IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
1381 IN u32 val0x6c8, IN u8 val0x6cc)
1382 {
1383 coex_dm->cur_val0x6c0 = val0x6c0;
1384 coex_dm->cur_val0x6c4 = val0x6c4;
1385 coex_dm->cur_val0x6c8 = val0x6c8;
1386 coex_dm->cur_val0x6cc = val0x6cc;
1387
1388 if (!force_exec) {
1389 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1390 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1391 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1392 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1393 return;
1394 }
1395 halbtc8723d2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1396 val0x6cc);
1397
1398 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1399 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1400 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1401 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1402 }
1403
halbtc8723d2ant_coex_table_with_type(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)1404 void halbtc8723d2ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
1405 IN boolean force_exec, IN u8 type)
1406 {
1407 u32 break_table;
1408 u8 select_table;
1409
1410 coex_sta->coex_table_type = type;
1411
1412 if (coex_sta->concurrent_rx_mode_on == TRUE) {
1413 break_table = 0xf0ffffff; /* set WL hi-pri can break BT */
1414 select_table =
1415 0xb; /* set Tx response = Hi-Pri (ex: Transmitting ACK,BA,CTS) */
1416 } else {
1417 break_table = 0xffffff;
1418 select_table = 0x3;
1419 }
1420
1421 switch (type) {
1422 case 0:
1423 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1424 0xffffffff, 0xffffffff, break_table, select_table);
1425 break;
1426 case 1:
1427 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1428 0x55555555, 0xfafafafa, break_table, select_table);
1429 break;
1430 case 2:
1431 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1432 0x5a5a5a5a, 0x5a5a5a5a, break_table, select_table);
1433 break;
1434 case 3:
1435 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1436 0x55555555, 0x5a5a5a5a, break_table, select_table);
1437 break;
1438 case 4:
1439 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1440 0xffff55ff, 0xfafafafa, break_table, select_table);
1441 break;
1442 case 5:
1443 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1444 0x55555555, 0x55555555, break_table, select_table);
1445 break;
1446 case 6:
1447 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1448 0xaaffffaa, 0xfafafafa, break_table, select_table);
1449 break;
1450 case 7:
1451 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1452 0xaaffffaa, 0xfafafafa, break_table, select_table);
1453 break;
1454 case 8:
1455 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1456 0xffff55ff, 0xfafafafa, break_table, select_table);
1457 break;
1458 case 9:
1459 halbtc8723d2ant_coex_table(btcoexist, force_exec,
1460 0x5a5a5a5a, 0xaaaa5aaa, break_table, select_table);
1461 break;
1462 default:
1463 break;
1464 }
1465 }
1466
halbtc8723d2ant_set_fw_ignore_wlan_act(IN struct btc_coexist * btcoexist,IN boolean enable)1467 void halbtc8723d2ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1468 IN boolean enable)
1469 {
1470 u8 h2c_parameter[1] = {0};
1471
1472 if (enable) {
1473 h2c_parameter[0] |= BIT(0); /* function enable */
1474 }
1475
1476 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1477 }
1478
halbtc8723d2ant_ignore_wlan_act(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean enable)1479 void halbtc8723d2ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1480 IN boolean force_exec, IN boolean enable)
1481 {
1482 coex_dm->cur_ignore_wlan_act = enable;
1483
1484 if (!force_exec) {
1485 if (coex_dm->pre_ignore_wlan_act ==
1486 coex_dm->cur_ignore_wlan_act)
1487 return;
1488 }
1489 halbtc8723d2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1490
1491 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1492 }
1493
halbtc8723d2ant_set_lps_rpwm(IN struct btc_coexist * btcoexist,IN u8 lps_val,IN u8 rpwm_val)1494 void halbtc8723d2ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
1495 IN u8 lps_val, IN u8 rpwm_val)
1496 {
1497 u8 lps = lps_val;
1498 u8 rpwm = rpwm_val;
1499
1500 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1501 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1502 }
1503
halbtc8723d2ant_lps_rpwm(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 lps_val,IN u8 rpwm_val)1504 void halbtc8723d2ant_lps_rpwm(IN struct btc_coexist *btcoexist,
1505 IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
1506 {
1507 coex_dm->cur_lps = lps_val;
1508 coex_dm->cur_rpwm = rpwm_val;
1509
1510 if (!force_exec) {
1511 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1512 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1513 return;
1514 }
1515 halbtc8723d2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1516
1517 coex_dm->pre_lps = coex_dm->cur_lps;
1518 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1519 }
1520
halbtc8723d2ant_ps_tdma_check_for_power_save_state(IN struct btc_coexist * btcoexist,IN boolean new_ps_state)1521 void halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1522 IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
1523 {
1524 u8 lps_mode = 0x0;
1525 u8 h2c_parameter[5] = {0, 0, 0, 0x40, 0};
1526
1527 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1528
1529 if (lps_mode) { /* already under LPS state */
1530 if (new_ps_state) {
1531 /* keep state under LPS, do nothing. */
1532 } else {
1533 /* will leave LPS state, turn off psTdma first */
1534 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1535 h2c_parameter);
1536 }
1537 } else { /* NO PS state */
1538 if (new_ps_state) {
1539 /* will enter LPS state, turn off psTdma first */
1540 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1541 h2c_parameter);
1542 } else {
1543 /* keep state under NO PS state, do nothing. */
1544 }
1545 }
1546 }
1547
halbtc8723d2ant_power_save_state(IN struct btc_coexist * btcoexist,IN u8 ps_type,IN u8 lps_val,IN u8 rpwm_val)1548 void halbtc8723d2ant_power_save_state(IN struct btc_coexist *btcoexist,
1549 IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
1550 {
1551 boolean low_pwr_disable = FALSE;
1552
1553 switch (ps_type) {
1554 case BTC_PS_WIFI_NATIVE:
1555 coex_sta->force_lps_ctrl = FALSE;
1556 /* recover to original 32k low power setting */
1557 low_pwr_disable = FALSE;
1558 /* btcoexist->btc_set(btcoexist,
1559 BTC_SET_ACT_DISABLE_LOW_POWER,
1560 &low_pwr_disable); */
1561 btcoexist->btc_set(btcoexist, BTC_SET_ACT_PRE_NORMAL_LPS,
1562 NULL);
1563 break;
1564 case BTC_PS_LPS_ON:
1565 coex_sta->force_lps_ctrl = TRUE;
1566 halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1567 btcoexist, TRUE);
1568 halbtc8723d2ant_lps_rpwm(btcoexist, NORMAL_EXEC,
1569 lps_val, rpwm_val);
1570 /* when coex force to enter LPS, do not enter 32k low power. */
1571 low_pwr_disable = TRUE;
1572 btcoexist->btc_set(btcoexist,
1573 BTC_SET_ACT_DISABLE_LOW_POWER,
1574 &low_pwr_disable);
1575 /* power save must executed before psTdma. */
1576 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
1577 NULL);
1578 break;
1579 case BTC_PS_LPS_OFF:
1580 coex_sta->force_lps_ctrl = TRUE;
1581 halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1582 btcoexist, FALSE);
1583 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1584 NULL);
1585 break;
1586 default:
1587 break;
1588 }
1589 }
1590
1591
1592
halbtc8723d2ant_set_fw_pstdma(IN struct btc_coexist * btcoexist,IN u8 byte1,IN u8 byte2,IN u8 byte3,IN u8 byte4,IN u8 byte5)1593 void halbtc8723d2ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
1594 IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
1595 {
1596 u8 h2c_parameter[5] = {0};
1597 u8 real_byte1 = byte1, real_byte5 = byte5;
1598 boolean ap_enable = FALSE;
1599 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1600 u8 ps_type = BTC_PS_WIFI_NATIVE;
1601
1602 if (byte5 & BIT(2))
1603 coex_sta->is_tdma_btautoslot = TRUE;
1604 else
1605 coex_sta->is_tdma_btautoslot = FALSE;
1606
1607 /* release bt-auto slot for auto-slot hang is detected!! */
1608 if (coex_sta->is_tdma_btautoslot)
1609 if ((coex_sta->is_tdma_btautoslot_hang) ||
1610 (bt_link_info->slave_role))
1611 byte5 = byte5 & 0xfb;
1612
1613 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1614 &ap_enable);
1615
1616 if ((ap_enable) && (byte1 & BIT(4) && !(byte1 & BIT(5)))) {
1617 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1618 "[BTCoex], FW for AP mode\n");
1619 BTC_TRACE(trace_buf);
1620 real_byte1 &= ~BIT(4);
1621 real_byte1 |= BIT(5);
1622
1623 real_byte5 |= BIT(5);
1624 real_byte5 &= ~BIT(6);
1625
1626 ps_type = BTC_PS_WIFI_NATIVE;
1627 halbtc8723d2ant_power_save_state(btcoexist,
1628 ps_type, 0x0,
1629 0x0);
1630 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1631
1632 ps_type = BTC_PS_LPS_ON;
1633 halbtc8723d2ant_power_save_state(
1634 btcoexist, ps_type, 0x50,
1635 0x4);
1636 } else {
1637 ps_type = BTC_PS_WIFI_NATIVE;
1638 halbtc8723d2ant_power_save_state(btcoexist, ps_type,
1639 0x0,
1640 0x0);
1641 }
1642
1643
1644 h2c_parameter[0] = real_byte1;
1645 h2c_parameter[1] = byte2;
1646 h2c_parameter[2] = byte3;
1647 h2c_parameter[3] = byte4;
1648 h2c_parameter[4] = real_byte5;
1649
1650 coex_dm->ps_tdma_para[0] = real_byte1;
1651 coex_dm->ps_tdma_para[1] = byte2;
1652 coex_dm->ps_tdma_para[2] = byte3;
1653 coex_dm->ps_tdma_para[3] = byte4;
1654 coex_dm->ps_tdma_para[4] = real_byte5;
1655
1656 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1657
1658 if (ps_type == BTC_PS_WIFI_NATIVE)
1659 btcoexist->btc_set(btcoexist, BTC_SET_ACT_POST_NORMAL_LPS, NULL);
1660 }
1661
halbtc8723d2ant_ps_tdma(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean turn_on,IN u8 type)1662 void halbtc8723d2ant_ps_tdma(IN struct btc_coexist *btcoexist,
1663 IN boolean force_exec, IN boolean turn_on, IN u8 type)
1664 {
1665
1666 static u8 psTdmaByte4Modify = 0x0, pre_psTdmaByte4Modify = 0x0;
1667 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1668
1669
1670 coex_dm->cur_ps_tdma_on = turn_on;
1671 coex_dm->cur_ps_tdma = type;
1672
1673 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1674 if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1675 psTdmaByte4Modify = 0x1;
1676 else
1677 psTdmaByte4Modify = 0x0;
1678
1679 if (pre_psTdmaByte4Modify != psTdmaByte4Modify) {
1680
1681 force_exec = TRUE;
1682 pre_psTdmaByte4Modify = psTdmaByte4Modify;
1683 }
1684
1685 if (!force_exec) {
1686 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1687 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1688 return;
1689 }
1690
1691 if (coex_dm->cur_ps_tdma_on) {
1692 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1693 "[BTCoex], ********** TDMA(on, %d) **********\n",
1694 coex_dm->cur_ps_tdma);
1695 BTC_TRACE(trace_buf);
1696
1697 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
1698 0x1); /* enable TBTT nterrupt */
1699 } else {
1700 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1701 "[BTCoex], ********** TDMA(off, %d) **********\n",
1702 coex_dm->cur_ps_tdma);
1703 BTC_TRACE(trace_buf);
1704 }
1705
1706
1707 if (turn_on) {
1708 switch (type) {
1709 case 1:
1710 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1711 0x10, 0x03, 0x91,
1712 0x54 | psTdmaByte4Modify);
1713 break;
1714 case 2:
1715 default:
1716 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1717 0x35, 0x03, 0x11,
1718 0x11 | psTdmaByte4Modify);
1719 break;
1720 case 3:
1721 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1722 0x3a, 0x3, 0x91,
1723 0x10 | psTdmaByte4Modify);
1724 break;
1725 case 4:
1726 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1727 0x21, 0x3, 0x91,
1728 0x10 | psTdmaByte4Modify);
1729 break;
1730 case 5:
1731 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1732 0x25, 0x3, 0x91,
1733 0x10 | psTdmaByte4Modify);
1734 break;
1735 case 6:
1736 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1737 0x10, 0x3, 0x91,
1738 0x10 | psTdmaByte4Modify);
1739 break;
1740 case 7:
1741 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1742 0x20, 0x3, 0x91,
1743 0x10 | psTdmaByte4Modify);
1744 break;
1745 case 8:
1746 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1747 0x15, 0x03, 0x11,
1748 0x11);
1749 break;
1750 case 10:
1751 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1752 0x30, 0x03, 0x11,
1753 0x10);
1754 break;
1755 case 11:
1756 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1757 0x35, 0x03, 0x11,
1758 0x10 | psTdmaByte4Modify);
1759 break;
1760 case 12:
1761 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1762 0x35, 0x03, 0x11, 0x11);
1763 break;
1764 case 13:
1765 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1766 0x1c, 0x03, 0x11,
1767 0x10 | psTdmaByte4Modify);
1768 break;
1769 case 14:
1770 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1771 0x20, 0x03, 0x11,
1772 0x11);
1773 break;
1774 case 15:
1775 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1776 0x10, 0x03, 0x11,
1777 0x14);
1778 break;
1779 case 16:
1780 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1781 0x10, 0x03, 0x11,
1782 0x15);
1783 break;
1784 case 21:
1785 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1786 0x30, 0x03, 0x11,
1787 0x10);
1788 break;
1789 case 22:
1790 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1791 0x25, 0x03, 0x11,
1792 0x10);
1793 break;
1794 case 23:
1795 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1796 0x10, 0x03, 0x11,
1797 0x10);
1798 break;
1799 case 51:
1800 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1801 0x10, 0x03, 0x91,
1802 0x10 | psTdmaByte4Modify);
1803 break;
1804 case 101:
1805 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1806 0x10, 0x03, 0x10,
1807 0x54 | psTdmaByte4Modify);
1808 break;
1809 case 102:
1810 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1811 0x35, 0x03, 0x11,
1812 0x11 | psTdmaByte4Modify);
1813 break;
1814 case 103:
1815 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1816 0x30, 0x3, 0x10,
1817 0x50 | psTdmaByte4Modify);
1818 break;
1819 case 104:
1820 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1821 0x21, 0x3, 0x10,
1822 0x50 | psTdmaByte4Modify);
1823 break;
1824 case 105:
1825 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1826 0x35, 0x3, 0x10,
1827 0x50 | psTdmaByte4Modify);
1828 break;
1829 case 106:
1830 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1831 0x10, 0x3, 0x10,
1832 0x50 | psTdmaByte4Modify);
1833 break;
1834 case 107:
1835 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1836 0x10, 0x7, 0x10,
1837 0x54 | psTdmaByte4Modify);
1838 break;
1839 case 108:
1840 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1841 0x30, 0x3, 0x10,
1842 0x50 | psTdmaByte4Modify);
1843 break;
1844 case 109:
1845 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1846 0x10, 0x03, 0x10,
1847 0x54 | psTdmaByte4Modify);
1848 break;
1849 case 110:
1850 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1851 0x30, 0x03, 0x10,
1852 0x50 | psTdmaByte4Modify);
1853 break;
1854 case 111:
1855 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1856 0x25, 0x03, 0x11,
1857 0x11);
1858 break;
1859 case 112:
1860 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1861 0x4a, 0x3, 0x10,
1862 0x50);
1863 break;
1864 case 116:
1865 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1866 0x08, 0x03, 0x10,
1867 0x54 | psTdmaByte4Modify);
1868 break;
1869 case 117:
1870 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1871 0x08, 0x03, 0x10,
1872 0x14 | psTdmaByte4Modify);
1873 break;
1874 case 119:
1875 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1876 0x10, 0x03, 0x11,
1877 0x14 | psTdmaByte4Modify);
1878 break;
1879 case 151:
1880 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1881 0x10, 0x03, 0x10,
1882 0x50 | psTdmaByte4Modify);
1883 break;
1884 }
1885 } else {
1886 /* disable PS tdma */
1887 switch (type) {
1888 case 0:
1889 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1890 0x0, 0x0, 0x40, 0x0);
1891 break;
1892 case 1:
1893 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1894 0x0, 0x0, 0x48, 0x0);
1895 break;
1896 default:
1897 halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1898 0x0, 0x0, 0x40, 0x0);
1899 break;
1900 }
1901 }
1902
1903 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1904 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1905
1906 }
1907
halbtc8723d2ant_set_ant_path(IN struct btc_coexist * btcoexist,IN u8 ant_pos_type,IN boolean force_exec,IN u8 phase)1908 void halbtc8723d2ant_set_ant_path(IN struct btc_coexist *btcoexist,
1909 IN u8 ant_pos_type, IN boolean force_exec,
1910 IN u8 phase)
1911 {
1912 struct btc_board_info *board_info = &btcoexist->board_info;
1913 u32 u32tmp = 0;
1914 boolean pg_ext_switch = FALSE, is_hw_ant_div_on = FALSE;
1915 u8 h2c_parameter[2] = {0};
1916 u32 cnt_bt_cal_chk = 0;
1917 u8 u8tmp0 = 0, u8tmp1 = 0;
1918 boolean is_in_mp_mode = FALSE;
1919 u32 u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
1920 u16 u16tmp0 = 0, u16tmp1 = 0;
1921
1922
1923 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1924 0x38);
1925
1926 /* To avoid indirect access fail */
1927 if (((u32tmp1 & 0xf000) >> 12) != ((u32tmp1 & 0x0f00) >> 8)) {
1928 force_exec = TRUE;
1929 coex_sta->gnt_error_cnt++;
1930 }
1931
1932
1933 #if BT_8723D_2ANT_COEX_DBG
1934 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
1935 u16tmp0 = btcoexist->btc_read_2byte(btcoexist, 0xaa);
1936 u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1937 u8tmp1 = btcoexist->btc_read_1byte(btcoexist, 0x73);
1938 u8tmp0 = btcoexist->btc_read_1byte(btcoexist, 0x67);
1939
1940 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1941 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(Before Set Ant Pat)\n",
1942 u8tmp0, u16tmp1, u8tmp1);
1943 BTC_TRACE(trace_buf);
1944
1945 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1946 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x, 0xaa = 0x%x (Before Set Ant Path)\n",
1947 u32tmp1, u32tmp2, u16tmp0);
1948 BTC_TRACE(trace_buf);
1949 #endif
1950
1951 coex_dm->cur_ant_pos_type = ant_pos_type;
1952
1953 if (!force_exec) {
1954 if (coex_dm->cur_ant_pos_type == coex_dm->pre_ant_pos_type) {
1955
1956 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1957 "[BTCoex], ********** Skip Antenna Path Setup because no change!!**********\n");
1958 BTC_TRACE(trace_buf);
1959 return;
1960 }
1961 }
1962
1963 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
1964
1965 switch (phase) {
1966 case BT_8723D_2ANT_PHASE_COEX_POWERON:
1967 /* Set Path control to WL */
1968 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
1969 0x80, 0x0);
1970
1971 /* set Path control owner to WL at initial step */
1972 halbtc8723d2ant_ltecoex_pathcontrol_owner(btcoexist,
1973 BT_8723D_2ANT_PCO_BTSIDE);
1974
1975 /* set GNT_BT to SW high */
1976 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1977 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1978 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1979 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1980 /* Set GNT_WL to SW low */
1981 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1982 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1983 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1984 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1985
1986 if (BTC_ANT_PATH_AUTO == ant_pos_type)
1987 ant_pos_type = BTC_ANT_PATH_WIFI;
1988
1989 coex_sta->run_time_state = FALSE;
1990
1991 break;
1992 case BT_8723D_2ANT_PHASE_COEX_INIT:
1993 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
1994 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
1995
1996 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
1997 halbtc8723d2ant_ltecoex_set_coex_table(
1998 btcoexist,
1999 BT_8723D_2ANT_CTT_WL_VS_LTE,
2000 0xffff);
2001
2002 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
2003 halbtc8723d2ant_ltecoex_set_coex_table(
2004 btcoexist,
2005 BT_8723D_2ANT_CTT_BT_VS_LTE,
2006 0xffff);
2007
2008 /* Wait If BT IQK running, because Path control owner is at BT during BT IQK (setup by WiFi firmware) */
2009 while (cnt_bt_cal_chk <= 20) {
2010 u8tmp0 = btcoexist->btc_read_1byte(
2011 btcoexist,
2012 0x49d);
2013 cnt_bt_cal_chk++;
2014 if (u8tmp0 & BIT(0)) {
2015 BTC_SPRINTF(
2016 trace_buf,
2017 BT_TMP_BUF_SIZE,
2018 "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
2019 cnt_bt_cal_chk);
2020 BTC_TRACE(
2021 trace_buf);
2022 delay_ms(50);
2023 } else {
2024 BTC_SPRINTF(
2025 trace_buf,
2026 BT_TMP_BUF_SIZE,
2027 "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
2028 cnt_bt_cal_chk);
2029 BTC_TRACE(
2030 trace_buf);
2031 break;
2032 }
2033 }
2034
2035
2036 /* Set Path control to WL */
2037 btcoexist->btc_write_1byte_bitmask(btcoexist,
2038 0x67, 0x80, 0x1);
2039
2040 /* set Path control owner to WL at initial step */
2041 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2042 btcoexist,
2043 BT_8723D_2ANT_PCO_WLSIDE);
2044
2045 /* set GNT_BT to SW high */
2046 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2047 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2048 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2049 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2050 /* Set GNT_WL to SW high */
2051 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2052 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2053 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2054 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2055
2056 coex_sta->run_time_state = FALSE;
2057
2058 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2059 if (board_info->btdm_ant_pos ==
2060 BTC_ANTENNA_AT_MAIN_PORT)
2061 ant_pos_type =
2062 BTC_ANT_WIFI_AT_MAIN;
2063 else
2064 ant_pos_type =
2065 BTC_ANT_WIFI_AT_AUX;
2066 }
2067
2068 break;
2069 case BT_8723D_2ANT_PHASE_WLANONLY_INIT:
2070 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
2071 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
2072
2073 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
2074 halbtc8723d2ant_ltecoex_set_coex_table(
2075 btcoexist,
2076 BT_8723D_2ANT_CTT_WL_VS_LTE,
2077 0xffff);
2078
2079 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
2080 halbtc8723d2ant_ltecoex_set_coex_table(
2081 btcoexist,
2082 BT_8723D_2ANT_CTT_BT_VS_LTE,
2083 0xffff);
2084
2085 /* Set Path control to WL */
2086 btcoexist->btc_write_1byte_bitmask(btcoexist,
2087 0x67, 0x80, 0x1);
2088
2089 /* set Path control owner to WL at initial step */
2090 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2091 btcoexist,
2092 BT_8723D_2ANT_PCO_WLSIDE);
2093
2094 /* set GNT_BT to SW Low */
2095 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2096 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2097 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2098 BT_8723D_2ANT_SIG_STA_SET_TO_LOW);
2099 /* Set GNT_WL to SW high */
2100 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2101 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2102 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2103 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2104
2105 coex_sta->run_time_state = FALSE;
2106
2107 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2108 if (board_info->btdm_ant_pos ==
2109 BTC_ANTENNA_AT_MAIN_PORT)
2110 ant_pos_type =
2111 BTC_ANT_WIFI_AT_MAIN;
2112 else
2113 ant_pos_type =
2114 BTC_ANT_WIFI_AT_AUX;
2115 }
2116
2117 break;
2118 case BT_8723D_2ANT_PHASE_WLAN_OFF:
2119 /* Disable LTE Coex Function in WiFi side */
2120 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
2121
2122 /* Set Path control to BT */
2123 btcoexist->btc_write_1byte_bitmask(btcoexist,
2124 0x67, 0x80, 0x0);
2125
2126 /* set Path control owner to BT */
2127 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2128 btcoexist,
2129 BT_8723D_2ANT_PCO_BTSIDE);
2130
2131 halbtc8723d2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, TRUE);
2132
2133 coex_sta->run_time_state = FALSE;
2134 break;
2135 case BT_8723D_2ANT_PHASE_2G_RUNTIME:
2136
2137 /* wait for WL/BT IQK finish, keep 0x38 = 0xff00 for WL IQK */
2138 while (cnt_bt_cal_chk <= 20) {
2139 u8tmp0 = btcoexist->btc_read_1byte(
2140 btcoexist,
2141 0x1e6);
2142
2143 u8tmp1 = btcoexist->btc_read_1byte(
2144 btcoexist,
2145 0x49d);
2146
2147 cnt_bt_cal_chk++;
2148 if ((u8tmp0 & BIT(0)) ||
2149 (u8tmp1 & BIT(0))) {
2150 BTC_SPRINTF(trace_buf,
2151 BT_TMP_BUF_SIZE,
2152 "[BTCoex], ########### WL or BT is IQK (wait cnt=%d)\n",
2153 cnt_bt_cal_chk);
2154 BTC_TRACE(trace_buf);
2155 delay_ms(50);
2156 } else {
2157 BTC_SPRINTF(trace_buf,
2158 BT_TMP_BUF_SIZE,
2159 "[BTCoex], ********** WL and BT is NOT IQK (wait cnt=%d)\n",
2160 cnt_bt_cal_chk);
2161 BTC_TRACE(trace_buf);
2162 break;
2163 }
2164 }
2165
2166 /* Set Path control to WL */
2167 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x80, 0x1);*/
2168
2169 /* set Path control owner to WL at runtime step */
2170 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2171 btcoexist,
2172 BT_8723D_2ANT_PCO_WLSIDE);
2173
2174
2175 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2176 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2177 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_PTA,
2178 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2179
2180 /* Set GNT_WL to PTA */
2181 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2182 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2183 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_PTA,
2184 BT_8723D_2ANT_SIG_STA_SET_BY_HW);
2185
2186 coex_sta->run_time_state = TRUE;
2187
2188 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2189 if (board_info->btdm_ant_pos ==
2190 BTC_ANTENNA_AT_MAIN_PORT)
2191 ant_pos_type =
2192 BTC_ANT_WIFI_AT_MAIN;
2193 else
2194 ant_pos_type =
2195 BTC_ANT_WIFI_AT_AUX;
2196 }
2197
2198 break;
2199 case BT_8723D_2ANT_PHASE_BTMPMODE:
2200 /* Disable LTE Coex Function in WiFi side */
2201 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
2202
2203 /* Set Path control to WL */
2204 btcoexist->btc_write_1byte_bitmask(btcoexist,
2205 0x67, 0x80, 0x1);
2206
2207 /* set Path control owner to WL */
2208 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2209 btcoexist,
2210 BT_8723D_2ANT_PCO_WLSIDE);
2211
2212 /* set GNT_BT to SW Hi */
2213 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2214 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2215 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2216 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2217
2218 /* Set GNT_WL to SW Lo */
2219 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2220 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2221 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2222 BT_8723D_2ANT_SIG_STA_SET_TO_LOW);
2223
2224 coex_sta->run_time_state = FALSE;
2225
2226 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2227 if (board_info->btdm_ant_pos ==
2228 BTC_ANTENNA_AT_MAIN_PORT)
2229 ant_pos_type =
2230 BTC_ANT_WIFI_AT_MAIN;
2231 else
2232 ant_pos_type =
2233 BTC_ANT_WIFI_AT_AUX;
2234 }
2235
2236 break;
2237 case BT_8723D_2ANT_PHASE_ANTENNA_DET:
2238
2239 /* Set Path control to WL */
2240 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
2241 0x80, 0x1);
2242
2243 /* set Path control owner to WL */
2244 halbtc8723d2ant_ltecoex_pathcontrol_owner(btcoexist,
2245 BT_8723D_2ANT_PCO_WLSIDE);
2246
2247 /* Set Antenna Path, both GNT_WL/GNT_BT = 1, and control by SW */
2248 /* set GNT_BT to SW high */
2249 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2250 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2251 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2252 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2253
2254 /* Set GNT_WL to SW high */
2255 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2256 BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2257 BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2258 BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2259
2260 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2261 ant_pos_type = BTC_ANT_WIFI_AT_AUX;
2262
2263 coex_sta->run_time_state = FALSE;
2264
2265 break;
2266 }
2267
2268 is_hw_ant_div_on = board_info->ant_div_cfg;
2269
2270 if ((is_hw_ant_div_on) && (phase != BT_8723D_2ANT_PHASE_ANTENNA_DET))
2271 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x140);
2272 else if ((is_hw_ant_div_on == FALSE) &&
2273 (phase != BT_8723D_2ANT_PHASE_WLAN_OFF)) {
2274
2275 switch (ant_pos_type) {
2276 case BTC_ANT_WIFI_AT_MAIN:
2277
2278 btcoexist->btc_write_2byte(btcoexist,
2279 0x948, 0x0);
2280 break;
2281 case BTC_ANT_WIFI_AT_AUX:
2282
2283 btcoexist->btc_write_2byte(btcoexist,
2284 0x948, 0x280);
2285 break;
2286 }
2287 }
2288
2289
2290 #if BT_8723D_2ANT_COEX_DBG
2291 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
2292 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
2293 u16tmp0 = btcoexist->btc_read_2byte(btcoexist, 0xaa);
2294 u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
2295 u8tmp1 = btcoexist->btc_read_1byte(btcoexist, 0x73);
2296 u8tmp0 = btcoexist->btc_read_1byte(btcoexist, 0x67);
2297
2298 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2299 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(After Set Ant Pat)\n",
2300 u8tmp0, u16tmp1, u8tmp1);
2301 BTC_TRACE(trace_buf);
2302
2303 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2304 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x, 0xaa= 0x%x (After Set Ant Path)\n",
2305 u32tmp1, u32tmp2, u16tmp0);
2306 BTC_TRACE(trace_buf);
2307 #endif
2308
2309 }
2310
halbtc8723d2ant_action_algorithm(IN struct btc_coexist * btcoexist)2311 u8 halbtc8723d2ant_action_algorithm(IN struct btc_coexist *btcoexist)
2312 {
2313 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2314 boolean bt_hs_on = FALSE;
2315 u8 algorithm = BT_8723D_2ANT_COEX_ALGO_UNDEFINED;
2316 u8 num_of_diff_profile = 0;
2317
2318 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2319
2320 if (!bt_link_info->bt_link_exist) {
2321 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2322 "[BTCoex], No BT link exists!!!\n");
2323 BTC_TRACE(trace_buf);
2324 return algorithm;
2325 }
2326
2327 if (bt_link_info->sco_exist)
2328 num_of_diff_profile++;
2329 if (bt_link_info->hid_exist)
2330 num_of_diff_profile++;
2331 if (bt_link_info->pan_exist)
2332 num_of_diff_profile++;
2333 if (bt_link_info->a2dp_exist)
2334 num_of_diff_profile++;
2335
2336 if (num_of_diff_profile == 0) {
2337
2338 if (bt_link_info->acl_busy) {
2339 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2340 "[BTCoex], No-Profile busy\n");
2341 BTC_TRACE(trace_buf);
2342 algorithm = BT_8723D_2ANT_COEX_ALGO_NOPROFILEBUSY;
2343 }
2344 } else if ((bt_link_info->a2dp_exist) && (coex_sta->is_bt_a2dp_sink)) {
2345 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2346 "[BTCoex], A2DP Sink\n");
2347 BTC_TRACE(trace_buf);
2348 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DPSINK;
2349 } else if (num_of_diff_profile == 1) {
2350 if (bt_link_info->sco_exist) {
2351 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2352 "[BTCoex], SCO only\n");
2353 BTC_TRACE(trace_buf);
2354 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2355 } else {
2356 if (bt_link_info->hid_exist) {
2357 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2358 "[BTCoex], HID only\n");
2359 BTC_TRACE(trace_buf);
2360 algorithm = BT_8723D_2ANT_COEX_ALGO_HID;
2361 } else if (bt_link_info->a2dp_exist) {
2362 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2363 "[BTCoex], A2DP only\n");
2364 BTC_TRACE(trace_buf);
2365 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DP;
2366 } else if (bt_link_info->pan_exist) {
2367 if (bt_hs_on) {
2368 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2369 "[BTCoex], PAN(HS) only\n");
2370 BTC_TRACE(trace_buf);
2371 algorithm =
2372 BT_8723D_2ANT_COEX_ALGO_PANHS;
2373 } else {
2374 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2375 "[BTCoex], PAN(EDR) only\n");
2376 BTC_TRACE(trace_buf);
2377 algorithm =
2378 BT_8723D_2ANT_COEX_ALGO_PANEDR;
2379 }
2380 }
2381 }
2382 } else if (num_of_diff_profile == 2) {
2383 if (bt_link_info->sco_exist) {
2384 if (bt_link_info->hid_exist) {
2385 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2386 "[BTCoex], SCO + HID\n");
2387 BTC_TRACE(trace_buf);
2388 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2389 } else if (bt_link_info->a2dp_exist) {
2390 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2391 "[BTCoex], SCO + A2DP ==> A2DP\n");
2392 BTC_TRACE(trace_buf);
2393 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DP;
2394 } else if (bt_link_info->pan_exist) {
2395 if (bt_hs_on) {
2396 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2397 "[BTCoex], SCO + PAN(HS)\n");
2398 BTC_TRACE(trace_buf);
2399 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2400 } else {
2401 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2402 "[BTCoex], SCO + PAN(EDR)\n");
2403 BTC_TRACE(trace_buf);
2404 algorithm =
2405 BT_8723D_2ANT_COEX_ALGO_PANEDR;
2406 }
2407 }
2408 } else {
2409 if (bt_link_info->hid_exist &&
2410 bt_link_info->a2dp_exist) {
2411 {
2412 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2413 "[BTCoex], HID + A2DP\n");
2414 BTC_TRACE(trace_buf);
2415 algorithm =
2416 BT_8723D_2ANT_COEX_ALGO_HID_A2DP;
2417 }
2418 } else if (bt_link_info->hid_exist &&
2419 bt_link_info->pan_exist) {
2420 if (bt_hs_on) {
2421 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2422 "[BTCoex], HID + PAN(HS)\n");
2423 BTC_TRACE(trace_buf);
2424 algorithm = BT_8723D_2ANT_COEX_ALGO_HID;
2425 } else {
2426 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2427 "[BTCoex], HID + PAN(EDR)\n");
2428 BTC_TRACE(trace_buf);
2429 algorithm =
2430 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2431 }
2432 } else if (bt_link_info->pan_exist &&
2433 bt_link_info->a2dp_exist) {
2434 if (bt_hs_on) {
2435 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2436 "[BTCoex], A2DP + PAN(HS)\n");
2437 BTC_TRACE(trace_buf);
2438 algorithm =
2439 BT_8723D_2ANT_COEX_ALGO_A2DP_PANHS;
2440 } else {
2441 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2442 "[BTCoex], A2DP + PAN(EDR)\n");
2443 BTC_TRACE(trace_buf);
2444 algorithm =
2445 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2446 }
2447 }
2448 }
2449 } else if (num_of_diff_profile == 3) {
2450 if (bt_link_info->sco_exist) {
2451 if (bt_link_info->hid_exist &&
2452 bt_link_info->a2dp_exist) {
2453 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2454 "[BTCoex], SCO + HID + A2DP ==> HID + A2DP\n");
2455 BTC_TRACE(trace_buf);
2456 algorithm = BT_8723D_2ANT_COEX_ALGO_HID_A2DP;
2457 } else if (bt_link_info->hid_exist &&
2458 bt_link_info->pan_exist) {
2459 if (bt_hs_on) {
2460 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2461 "[BTCoex], SCO + HID + PAN(HS)\n");
2462 BTC_TRACE(trace_buf);
2463 algorithm =
2464 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2465 } else {
2466 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2467 "[BTCoex], SCO + HID + PAN(EDR)\n");
2468 BTC_TRACE(trace_buf);
2469 algorithm =
2470 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2471 }
2472 } else if (bt_link_info->pan_exist &&
2473 bt_link_info->a2dp_exist) {
2474 if (bt_hs_on) {
2475 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2476 "[BTCoex], SCO + A2DP + PAN(HS)\n");
2477 BTC_TRACE(trace_buf);
2478 algorithm =
2479 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2480 } else {
2481 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2482 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
2483 BTC_TRACE(trace_buf);
2484 algorithm =
2485 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2486 }
2487 }
2488 } else {
2489 if (bt_link_info->hid_exist &&
2490 bt_link_info->pan_exist &&
2491 bt_link_info->a2dp_exist) {
2492 if (bt_hs_on) {
2493 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2494 "[BTCoex], HID + A2DP + PAN(HS)\n");
2495 BTC_TRACE(trace_buf);
2496 algorithm =
2497 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2498 } else {
2499 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2500 "[BTCoex], HID + A2DP + PAN(EDR)\n");
2501 BTC_TRACE(trace_buf);
2502 algorithm =
2503 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2504 }
2505 }
2506 }
2507 } else if (num_of_diff_profile >= 3) {
2508 if (bt_link_info->sco_exist) {
2509 if (bt_link_info->hid_exist &&
2510 bt_link_info->pan_exist &&
2511 bt_link_info->a2dp_exist) {
2512 if (bt_hs_on) {
2513 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2514 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
2515 BTC_TRACE(trace_buf);
2516 algorithm =
2517 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2518 } else {
2519 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2520 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
2521 BTC_TRACE(trace_buf);
2522 algorithm =
2523 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2524 }
2525 }
2526 }
2527 }
2528
2529 return algorithm;
2530 }
2531
2532
2533
halbtc8723d2ant_action_coex_all_off(IN struct btc_coexist * btcoexist)2534 void halbtc8723d2ant_action_coex_all_off(IN struct btc_coexist *btcoexist)
2535 {
2536
2537 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2538 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2539 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2540
2541 /* fw all off */
2542 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2543 }
2544
halbtc8723d2ant_action_bt_whql_test(IN struct btc_coexist * btcoexist)2545 void halbtc8723d2ant_action_bt_whql_test(IN struct btc_coexist *btcoexist)
2546 {
2547 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2548 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2549
2550 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2551
2552 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2553 }
2554
halbtc8723d2ant_action_bt_hs(IN struct btc_coexist * btcoexist)2555 void halbtc8723d2ant_action_bt_hs(IN struct btc_coexist *btcoexist)
2556 {
2557 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2558 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2559 u8 wifi_rssi_state, bt_rssi_state;
2560
2561 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2562 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2563 u8 wifi_rssi_state2, bt_rssi_state2;
2564 boolean wifi_busy = FALSE, wifi_turbo = FALSE;
2565
2566
2567 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2568 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2569 &coex_sta->scan_ap_num);
2570 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2571 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
2572 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2573 BTC_TRACE(trace_buf);
2574
2575 #if 1
2576 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2577 wifi_turbo = TRUE;
2578 #endif
2579
2580
2581 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2582 &prewifi_rssi_state, 2,
2583 coex_sta->wifi_coex_thres , 0);
2584
2585 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2586 &prewifi_rssi_state2, 2,
2587 coex_sta->wifi_coex_thres2, 0);
2588
2589 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
2590 &pre_bt_rssi_state, 2,
2591 coex_sta->bt_coex_thres, 0);
2592
2593 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
2594 &pre_bt_rssi_state2, 2,
2595 coex_sta->bt_coex_thres2, 0);
2596
2597 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2598 BTC_RSSI_HIGH(bt_rssi_state)) {
2599
2600 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2601 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2602
2603 coex_dm->is_switch_to_1dot5_ant = FALSE;
2604
2605 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2606
2607 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2608 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2609 BTC_RSSI_HIGH(bt_rssi_state2)) {
2610
2611 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2612 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2613
2614 coex_dm->is_switch_to_1dot5_ant = FALSE;
2615
2616 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2617
2618 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2619
2620
2621 } else {
2622
2623 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2624 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2625
2626 coex_dm->is_switch_to_1dot5_ant = TRUE;
2627
2628 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2629
2630 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2631 }
2632
2633 }
2634
2635
halbtc8723d2ant_action_bt_inquiry(IN struct btc_coexist * btcoexist)2636 void halbtc8723d2ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
2637 {
2638
2639 boolean wifi_connected = FALSE;
2640 boolean wifi_scan = FALSE, wifi_link = FALSE, wifi_roam = FALSE;
2641 boolean wifi_busy = FALSE;
2642 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2643
2644
2645 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2646
2647 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2648 &wifi_connected);
2649
2650 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
2651 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
2652 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
2653
2654 if ((coex_sta->bt_create_connection) && ((wifi_link) || (wifi_roam)
2655 || (wifi_scan) || (wifi_busy) || (coex_sta->wifi_is_high_pri_task))) {
2656
2657 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2658 "[BTCoex], Wifi link/roam/Scan/busy/hi-pri-task + BT Inq/Page!!\n");
2659 BTC_TRACE(trace_buf);
2660
2661 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2662 8);
2663
2664 if ((bt_link_info->a2dp_exist) && (!bt_link_info->pan_exist))
2665 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE,
2666 15);
2667 else
2668 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE,
2669 11);
2670 } else if ((!wifi_connected) && (!wifi_scan)) {
2671
2672 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2673 "[BTCoex], Wifi no-link + no-scan + BT Inq/Page!!\n");
2674 BTC_TRACE(trace_buf);
2675
2676 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2677
2678 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2679 } else if (bt_link_info->pan_exist) {
2680
2681 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2682
2683 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 22);
2684 } else if (bt_link_info->a2dp_exist) {
2685
2686 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2687
2688 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 16);
2689 } else {
2690
2691 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2692
2693 if ((wifi_link) || (wifi_roam) || (wifi_scan) || (wifi_busy)
2694 || (coex_sta->wifi_is_high_pri_task))
2695 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 21);
2696 else
2697 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 23);
2698 }
2699
2700 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2701 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2702 }
2703
2704
halbtc8723d2ant_action_bt_relink(IN struct btc_coexist * btcoexist)2705 void halbtc8723d2ant_action_bt_relink(IN struct btc_coexist *btcoexist)
2706 {
2707 if (coex_sta->is_bt_multi_link == TRUE)
2708 return;
2709
2710 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2711 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2712 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2713 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 8);
2714 }
2715
halbtc8723d2ant_action_bt_idle(IN struct btc_coexist * btcoexist)2716 void halbtc8723d2ant_action_bt_idle(IN struct btc_coexist *btcoexist)
2717 {
2718 boolean wifi_busy = FALSE;
2719
2720 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2721
2722 if (!wifi_busy) {
2723
2724 halbtc8723d2ant_coex_table_with_type(btcoexist,
2725 NORMAL_EXEC, 8);
2726
2727 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 14);
2728 } else { /* if wl busy */
2729
2730 if (BT_8723D_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2731 coex_dm->bt_status) {
2732
2733 halbtc8723d2ant_coex_table_with_type(btcoexist,
2734 NORMAL_EXEC, 0);
2735
2736 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2737 } else {
2738
2739 halbtc8723d2ant_coex_table_with_type(btcoexist,
2740 NORMAL_EXEC, 8);
2741 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE,
2742 12);
2743 }
2744 }
2745
2746 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2747 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2748
2749 }
2750
2751
2752
2753 /* SCO only or SCO+PAN(HS) */
halbtc8723d2ant_action_sco(IN struct btc_coexist * btcoexist)2754 void halbtc8723d2ant_action_sco(IN struct btc_coexist *btcoexist)
2755 {
2756 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2757 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2758 u8 wifi_rssi_state, bt_rssi_state;
2759
2760 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2761 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2762 u8 wifi_rssi_state2, bt_rssi_state2;
2763 boolean wifi_busy = FALSE;
2764 u32 wifi_bw = 1;
2765
2766 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2767 &wifi_bw);
2768
2769 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2770
2771 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2772 &prewifi_rssi_state, 2,
2773 coex_sta->wifi_coex_thres , 0);
2774
2775 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2776 &prewifi_rssi_state2, 2,
2777 coex_sta->wifi_coex_thres2, 0);
2778
2779 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
2780 &pre_bt_rssi_state, 2,
2781 coex_sta->bt_coex_thres, 0);
2782
2783 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
2784 &pre_bt_rssi_state2, 2,
2785 coex_sta->bt_coex_thres2, 0);
2786
2787
2788 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2789 BTC_RSSI_HIGH(bt_rssi_state)) {
2790
2791 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2792 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2793
2794 coex_dm->is_switch_to_1dot5_ant = FALSE;
2795
2796 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2797
2798 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2799 } else {
2800
2801 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2802 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2803
2804 coex_dm->is_switch_to_1dot5_ant = FALSE;
2805
2806 if (coex_sta->is_eSCO_mode)
2807 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2808 else /* 2-Ant free run if eSCO mode */
2809 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2810
2811 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 8);
2812 }
2813
2814 }
2815
2816
halbtc8723d2ant_action_hid(IN struct btc_coexist * btcoexist)2817 void halbtc8723d2ant_action_hid(IN struct btc_coexist *btcoexist)
2818 {
2819 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2820 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2821 u8 wifi_rssi_state, bt_rssi_state;
2822
2823 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2824 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2825 u8 wifi_rssi_state2, bt_rssi_state2;
2826 boolean wifi_busy = FALSE;
2827 u32 wifi_bw = 1;
2828
2829
2830 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2831 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2832
2833 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2834 &prewifi_rssi_state, 2,
2835 coex_sta->wifi_coex_thres , 0);
2836
2837 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2838 &prewifi_rssi_state2, 2,
2839 coex_sta->wifi_coex_thres2, 0);
2840
2841 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
2842 &pre_bt_rssi_state, 2,
2843 coex_sta->bt_coex_thres, 0);
2844
2845 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
2846 &pre_bt_rssi_state2, 2,
2847 coex_sta->bt_coex_thres2, 0);
2848
2849
2850 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2851 BTC_RSSI_HIGH(bt_rssi_state)) {
2852
2853 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2854 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2855
2856 coex_dm->is_switch_to_1dot5_ant = FALSE;
2857
2858 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2859
2860 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2861 } else {
2862
2863 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2864 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2865
2866 coex_dm->is_switch_to_1dot5_ant = FALSE;
2867
2868 if (coex_sta->is_hid_low_pri_tx_overhead) {
2869
2870 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2871 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 108);
2872 } else if (wifi_bw == 0) { /* if 11bg mode */
2873
2874 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2875 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 111);
2876 } else {
2877
2878 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2879 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 111);
2880 }
2881 }
2882
2883 }
2884
halbtc8723d2ant_action_a2dpsink(IN struct btc_coexist * btcoexist)2885 void halbtc8723d2ant_action_a2dpsink(IN struct btc_coexist *btcoexist)
2886 {
2887 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2888 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2889 u8 wifi_rssi_state, bt_rssi_state;
2890
2891 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2892 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2893 u8 wifi_rssi_state2, bt_rssi_state2;
2894 boolean wifi_busy = FALSE, wifi_turbo = FALSE;
2895 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2896
2897
2898 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2899 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2900 &coex_sta->scan_ap_num);
2901 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2902 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
2903 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2904 BTC_TRACE(trace_buf);
2905
2906 #if 1
2907 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2908 wifi_turbo = TRUE;
2909 #endif
2910
2911 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2912 &prewifi_rssi_state, 2,
2913 coex_sta->wifi_coex_thres, 0);
2914
2915 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2916 &prewifi_rssi_state2, 2,
2917 coex_sta->wifi_coex_thres2, 0);
2918
2919 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
2920 &pre_bt_rssi_state, 2,
2921 coex_sta->bt_coex_thres, 0);
2922
2923 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
2924 &pre_bt_rssi_state2, 2,
2925 coex_sta->bt_coex_thres2, 0);
2926
2927
2928 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2929 BTC_RSSI_HIGH(bt_rssi_state)) {
2930
2931 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2932 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2933
2934 coex_dm->is_switch_to_1dot5_ant = FALSE;
2935
2936 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2937
2938 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
2939 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2940 BTC_RSSI_HIGH(bt_rssi_state2)) {
2941
2942 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2943 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2944
2945 coex_dm->is_switch_to_1dot5_ant = FALSE;
2946
2947 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2948
2949 if (wifi_busy)
2950 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 1);
2951 else
2952 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 16);
2953 } else {
2954
2955 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2956 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2957
2958 coex_dm->is_switch_to_1dot5_ant = TRUE;
2959
2960 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2961 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 105);
2962 }
2963
2964 }
2965
2966 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
halbtc8723d2ant_action_a2dp(IN struct btc_coexist * btcoexist)2967 void halbtc8723d2ant_action_a2dp(IN struct btc_coexist *btcoexist)
2968 {
2969 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2970 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2971 u8 wifi_rssi_state, bt_rssi_state;
2972
2973 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2974 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2975 u8 wifi_rssi_state2, bt_rssi_state2;
2976
2977 static u8 prewifi_rssi_state3 = BTC_RSSI_STATE_LOW;
2978 static u8 pre_bt_rssi_state3 = BTC_RSSI_STATE_LOW;
2979 u8 wifi_rssi_state3, bt_rssi_state3;
2980
2981 boolean wifi_busy = FALSE, wifi_turbo = FALSE;
2982 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2983
2984
2985 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2986 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2987 &coex_sta->scan_ap_num);
2988 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2989
2990 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2991 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
2992 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2993 BTC_TRACE(trace_buf);
2994
2995 #if 1
2996 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2997 wifi_turbo = TRUE;
2998 #endif
2999
3000 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3001 &prewifi_rssi_state, 2,
3002 coex_sta->wifi_coex_thres , 0);
3003
3004 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3005 &prewifi_rssi_state2, 2,
3006 coex_sta->wifi_coex_thres2, 0);
3007
3008 wifi_rssi_state3 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3009 &prewifi_rssi_state3, 2,
3010 40, 0);
3011
3012 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3013 &pre_bt_rssi_state, 2,
3014 coex_sta->bt_coex_thres, 0);
3015
3016 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3017 &pre_bt_rssi_state2, 2,
3018 coex_sta->bt_coex_thres2, 0);
3019
3020 bt_rssi_state3 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3021 &pre_bt_rssi_state3, 2,
3022 coex_sta->bt_coex_thres2, 0);
3023
3024 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3025 BTC_RSSI_HIGH(bt_rssi_state)) {
3026
3027 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3028 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3029
3030 coex_dm->is_switch_to_1dot5_ant = FALSE;
3031
3032 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3033
3034 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3035 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3036 BTC_RSSI_HIGH(bt_rssi_state2)) {
3037
3038 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3039 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3040
3041 coex_dm->is_switch_to_1dot5_ant = FALSE;
3042
3043 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3044
3045 if (wifi_busy)
3046 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 1);
3047 else
3048 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 16);
3049 } else {
3050
3051 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3052 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3053
3054 coex_dm->is_switch_to_1dot5_ant = TRUE;
3055
3056 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3057 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 101);
3058 }
3059
3060 }
3061
3062
halbtc8723d2ant_action_pan_edr(IN struct btc_coexist * btcoexist)3063 void halbtc8723d2ant_action_pan_edr(IN struct btc_coexist *btcoexist)
3064 {
3065 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3066 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3067 u8 wifi_rssi_state, bt_rssi_state;
3068
3069 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3070 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3071 u8 wifi_rssi_state2, bt_rssi_state2;
3072 boolean wifi_busy = FALSE, wifi_turbo = FALSE;
3073
3074 static u8 prewifi_rssi_state3 = BTC_RSSI_STATE_LOW;
3075 static u8 pre_bt_rssi_state3 = BTC_RSSI_STATE_LOW;
3076 u8 wifi_rssi_state3, bt_rssi_state3;
3077
3078
3079 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3080 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &coex_sta->scan_ap_num);
3081
3082 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3083 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
3084 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3085 BTC_TRACE(trace_buf);
3086
3087 #if 1
3088 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3089 wifi_turbo = TRUE;
3090 #endif
3091
3092 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3093 &prewifi_rssi_state, 2,
3094 coex_sta->wifi_coex_thres , 0);
3095
3096 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3097 &prewifi_rssi_state2, 2,
3098 coex_sta->wifi_coex_thres2, 0);
3099
3100 wifi_rssi_state3 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3101 &prewifi_rssi_state3, 2,
3102 58, 0);
3103
3104 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3105 &pre_bt_rssi_state, 2,
3106 coex_sta->bt_coex_thres, 0);
3107
3108 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3109 &pre_bt_rssi_state2, 2,
3110 coex_sta->bt_coex_thres2, 0);
3111
3112 bt_rssi_state3 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3113 &pre_bt_rssi_state3, 2,
3114 47, 0);
3115
3116 #if 0
3117 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3118 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3119
3120 coex_dm->is_switch_to_1dot5_ant = FALSE;
3121
3122 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3123
3124 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3125 #endif
3126
3127
3128 #if 1
3129 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3130 BTC_RSSI_HIGH(bt_rssi_state)) {
3131
3132 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3133 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3134
3135 coex_dm->is_switch_to_1dot5_ant = FALSE;
3136
3137 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3138
3139 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3140 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3141 BTC_RSSI_HIGH(bt_rssi_state2)) {
3142
3143 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3144 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3145
3146 coex_dm->is_switch_to_1dot5_ant = FALSE;
3147
3148 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3149
3150 if (wifi_busy)
3151 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 3);
3152 else
3153 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 4);
3154 } else {
3155
3156 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3157 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3158
3159 coex_dm->is_switch_to_1dot5_ant = TRUE;
3160
3161 /* for Lenovo CPT_For_WiFi OPP test */
3162 if ((btcoexist->board_info.customerID == RT_CID_LENOVO_CHINA) &&
3163 BTC_RSSI_HIGH(wifi_rssi_state3) && (wifi_busy)) {
3164 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3165
3166 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 112);
3167 } else {
3168
3169 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3170
3171 if (wifi_busy)
3172 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 103);
3173 else
3174 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 104);
3175 }
3176 }
3177
3178 #endif
3179
3180 }
3181
halbtc8723d2ant_action_hid_a2dp(IN struct btc_coexist * btcoexist)3182 void halbtc8723d2ant_action_hid_a2dp(IN struct btc_coexist *btcoexist)
3183 {
3184 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3185 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3186 u8 wifi_rssi_state, bt_rssi_state;
3187
3188 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3189 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3190 u8 wifi_rssi_state2, bt_rssi_state2;
3191
3192 static u8 prewifi_rssi_state3 = BTC_RSSI_STATE_LOW;
3193 u8 wifi_rssi_state3;
3194
3195 boolean wifi_busy = FALSE;
3196 u32 wifi_bw = 1;
3197
3198 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3199 &wifi_bw);
3200 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3201
3202 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3203 &prewifi_rssi_state, 2,
3204 coex_sta->wifi_coex_thres , 0);
3205
3206 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3207 &prewifi_rssi_state2, 2,
3208 coex_sta->wifi_coex_thres2, 0);
3209
3210 wifi_rssi_state3 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3211 &prewifi_rssi_state3, 2,
3212 45, 0);
3213
3214 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3215 &pre_bt_rssi_state, 2,
3216 coex_sta->bt_coex_thres, 0);
3217
3218 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3219 &pre_bt_rssi_state2, 2,
3220 coex_sta->bt_coex_thres2, 0);
3221
3222
3223 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3224 BTC_RSSI_HIGH(bt_rssi_state)) {
3225
3226 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3227 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3228
3229 coex_dm->is_switch_to_1dot5_ant = FALSE;
3230
3231 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3232 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3233 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3234 BTC_RSSI_HIGH(bt_rssi_state2)) {
3235
3236 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3237 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3238
3239 coex_dm->is_switch_to_1dot5_ant = FALSE;
3240
3241 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3242
3243 if (wifi_busy)
3244 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 1);
3245 else
3246 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 16);
3247 } else {
3248
3249 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3250 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3251
3252 coex_dm->is_switch_to_1dot5_ant = TRUE;
3253
3254 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3255
3256 if (coex_sta->hid_pair_cnt > 1) {
3257 if (BTC_RSSI_HIGH(wifi_rssi_state3))
3258 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 117);
3259 else
3260 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 116);
3261 } else {
3262 if (BTC_RSSI_HIGH(wifi_rssi_state3))
3263 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 119);
3264 else
3265 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 109);
3266 }
3267 }
3268
3269 }
3270
3271
halbtc8723d2ant_action_a2dp_pan_hs(IN struct btc_coexist * btcoexist)3272 void halbtc8723d2ant_action_a2dp_pan_hs(IN struct btc_coexist *btcoexist)
3273 {
3274 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3275 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3276 u8 wifi_rssi_state, bt_rssi_state;
3277
3278 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3279 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3280 u8 wifi_rssi_state2, bt_rssi_state2;
3281 boolean wifi_busy = FALSE, wifi_turbo = FALSE;
3282
3283
3284 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3285 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3286 &coex_sta->scan_ap_num);
3287 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3288 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
3289 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3290 BTC_TRACE(trace_buf);
3291
3292 #if 1
3293 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3294 wifi_turbo = TRUE;
3295 #endif
3296
3297
3298 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3299 &prewifi_rssi_state, 2,
3300 coex_sta->wifi_coex_thres , 0);
3301
3302 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3303 &prewifi_rssi_state2, 2,
3304 coex_sta->wifi_coex_thres2, 0);
3305
3306 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3307 &pre_bt_rssi_state, 2,
3308 coex_sta->bt_coex_thres, 0);
3309
3310 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3311 &pre_bt_rssi_state2, 2,
3312 coex_sta->bt_coex_thres2, 0);
3313
3314
3315 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3316 BTC_RSSI_HIGH(bt_rssi_state)) {
3317
3318 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3319 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3320
3321 coex_dm->is_switch_to_1dot5_ant = FALSE;
3322
3323 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3324
3325 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3326 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3327 BTC_RSSI_HIGH(bt_rssi_state2)) {
3328
3329 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3330 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3331
3332 coex_dm->is_switch_to_1dot5_ant = FALSE;
3333
3334 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3335
3336 if (wifi_busy) {
3337
3338 if ((coex_sta->a2dp_bit_pool > 40) &&
3339 (coex_sta->a2dp_bit_pool < 255))
3340 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3341 TRUE, 7);
3342 else
3343 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3344 TRUE, 5);
3345 } else
3346 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE,
3347 6);
3348
3349 } else {
3350
3351 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3352 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3353
3354 coex_dm->is_switch_to_1dot5_ant = TRUE;
3355
3356 if (wifi_turbo)
3357 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
3358 else
3359 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3360
3361 if (wifi_busy) {
3362
3363 if ((coex_sta->a2dp_bit_pool > 40) &&
3364 (coex_sta->a2dp_bit_pool < 255))
3365 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 107);
3366 else
3367 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 105);
3368 } else
3369 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 106);
3370
3371 }
3372
3373 }
3374
3375
3376 /* PAN(EDR)+A2DP */
halbtc8723d2ant_action_pan_edr_a2dp(IN struct btc_coexist * btcoexist)3377 void halbtc8723d2ant_action_pan_edr_a2dp(IN struct btc_coexist *btcoexist)
3378 {
3379 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3380 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3381 u8 wifi_rssi_state, bt_rssi_state;
3382
3383 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3384 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3385 u8 wifi_rssi_state2, bt_rssi_state2;
3386
3387 static u8 prewifi_rssi_state3 = BTC_RSSI_STATE_LOW;
3388 static u8 pre_bt_rssi_state3 = BTC_RSSI_STATE_LOW;
3389 u8 wifi_rssi_state3, bt_rssi_state3;
3390
3391 boolean wifi_busy = FALSE, wifi_turbo = FALSE;
3392 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
3393
3394
3395 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3396 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3397 &coex_sta->scan_ap_num);
3398 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
3399
3400 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3401 "############# [BTCoex], scan_ap_num = %d, wl_noisy = %d\n",
3402 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3403 BTC_TRACE(trace_buf);
3404
3405 #if 1
3406 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3407 wifi_turbo = TRUE;
3408 #endif
3409
3410
3411 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3412 &prewifi_rssi_state, 2,
3413 coex_sta->wifi_coex_thres , 0);
3414
3415 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3416 &prewifi_rssi_state2, 2,
3417 coex_sta->wifi_coex_thres2, 0);
3418
3419 wifi_rssi_state3 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3420 &prewifi_rssi_state3, 2,
3421 40, 0);
3422
3423 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3424 &pre_bt_rssi_state, 2,
3425 coex_sta->bt_coex_thres, 0);
3426
3427 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3428 &pre_bt_rssi_state2, 2,
3429 coex_sta->bt_coex_thres2, 0);
3430
3431 bt_rssi_state3 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3432 &pre_bt_rssi_state3, 2,
3433 45, 0);
3434
3435 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3436 BTC_RSSI_HIGH(bt_rssi_state)) {
3437
3438 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3439 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3440
3441 coex_dm->is_switch_to_1dot5_ant = FALSE;
3442
3443 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3444 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3445 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3446 BTC_RSSI_HIGH(bt_rssi_state2)) {
3447
3448 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3449 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3450
3451 coex_dm->is_switch_to_1dot5_ant = FALSE;
3452
3453 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3454
3455 if (wifi_busy) {
3456
3457 if (((coex_sta->a2dp_bit_pool > 40) &&
3458 (coex_sta->a2dp_bit_pool < 255)) ||
3459 (!coex_sta->is_A2DP_3M))
3460 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 7);
3461 else
3462 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 5);
3463 } else
3464 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 6);
3465 } else {
3466
3467 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0xd8);
3468
3469 coex_dm->is_switch_to_1dot5_ant = TRUE;
3470
3471 /* for Lenovo coex test case */
3472 if ((btcoexist->board_info.customerID == RT_CID_LENOVO_CHINA) &&
3473 (coex_sta->scan_ap_num <= 10)) {
3474
3475 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3476
3477 /* for CPT_for_WiFi */
3478 if (BTC_RSSI_HIGH(bt_rssi_state3) && BTC_RSSI_LOW(wifi_rssi_state3)) {
3479 halbtc8723d2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 10);
3480 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 105);
3481 } else { /* for CPT_for_BT */
3482 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3483 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 107);
3484 }
3485 } else {
3486
3487 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3488 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3489
3490 if (wifi_busy)
3491 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 107);
3492 else
3493 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 106);
3494 }
3495 }
3496
3497 }
3498
3499
halbtc8723d2ant_action_pan_edr_hid(IN struct btc_coexist * btcoexist)3500 void halbtc8723d2ant_action_pan_edr_hid(IN struct btc_coexist *btcoexist)
3501 {
3502 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3503 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3504 u8 wifi_rssi_state, bt_rssi_state;
3505
3506 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3507 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3508 u8 wifi_rssi_state2, bt_rssi_state2;
3509 boolean wifi_busy = FALSE;
3510 u32 wifi_bw = 1;
3511
3512 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3513 &wifi_bw);
3514
3515 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3516
3517 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3518 &prewifi_rssi_state, 2,
3519 coex_sta->wifi_coex_thres , 0);
3520
3521 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3522 &prewifi_rssi_state2, 2,
3523 coex_sta->wifi_coex_thres2, 0);
3524
3525 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3526 &pre_bt_rssi_state, 2,
3527 coex_sta->bt_coex_thres, 0);
3528
3529 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3530 &pre_bt_rssi_state2, 2,
3531 coex_sta->bt_coex_thres2, 0);
3532
3533
3534 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3535 BTC_RSSI_HIGH(bt_rssi_state)) {
3536
3537 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3538 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3539
3540 coex_dm->is_switch_to_1dot5_ant = FALSE;
3541
3542 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3543 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3544 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3545 BTC_RSSI_HIGH(bt_rssi_state2)) {
3546
3547 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3548 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3549
3550 coex_dm->is_switch_to_1dot5_ant = FALSE;
3551
3552 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3553
3554 if (wifi_busy)
3555 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 3);
3556 else
3557 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 4);
3558 } else {
3559
3560 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3561 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3562
3563 coex_dm->is_switch_to_1dot5_ant = TRUE;
3564
3565 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3566
3567 if (wifi_busy)
3568 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 103);
3569 else
3570 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 104);
3571 }
3572
3573 }
3574
3575
3576 /* HID+A2DP+PAN(EDR) */
halbtc8723d2ant_action_hid_a2dp_pan_edr(IN struct btc_coexist * btcoexist)3577 void halbtc8723d2ant_action_hid_a2dp_pan_edr(IN struct btc_coexist *btcoexist)
3578 {
3579 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3580 static u8 pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3581 u8 wifi_rssi_state, bt_rssi_state;
3582
3583 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3584 static u8 pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3585 u8 wifi_rssi_state2, bt_rssi_state2;
3586 boolean wifi_busy = FALSE;
3587 u32 wifi_bw = 1;
3588
3589 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3590 &wifi_bw);
3591
3592 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3593
3594 wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3595 &prewifi_rssi_state, 2,
3596 coex_sta->wifi_coex_thres, 0);
3597
3598 wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3599 &prewifi_rssi_state2, 2,
3600 coex_sta->wifi_coex_thres2 , 0);
3601
3602 bt_rssi_state = halbtc8723d2ant_bt_rssi_state(btcoexist,
3603 &pre_bt_rssi_state, 2,
3604 coex_sta->bt_coex_thres, 0);
3605
3606 bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(btcoexist,
3607 &pre_bt_rssi_state2, 2,
3608 coex_sta->bt_coex_thres2, 0);
3609
3610
3611 if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3612 BTC_RSSI_HIGH(bt_rssi_state)) {
3613
3614 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3615 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3616
3617 coex_dm->is_switch_to_1dot5_ant = FALSE;
3618
3619 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3620 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3621 } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3622 BTC_RSSI_HIGH(bt_rssi_state2)) {
3623
3624 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3625 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3626
3627 coex_dm->is_switch_to_1dot5_ant = FALSE;
3628
3629 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3630
3631 if (wifi_busy) {
3632
3633 if (((coex_sta->a2dp_bit_pool > 40) &&
3634 (coex_sta->a2dp_bit_pool < 255)) ||
3635 (!coex_sta->is_A2DP_3M))
3636 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 7);
3637 else
3638 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 5);
3639 } else
3640 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 6);
3641 } else {
3642
3643 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3644 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3645
3646 coex_dm->is_switch_to_1dot5_ant = TRUE;
3647
3648 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3649
3650 if (wifi_busy)
3651 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 107);
3652 else
3653 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 106);
3654 }
3655
3656 }
3657
halbtc8723d2ant_action_wifi_native_lps(IN struct btc_coexist * btcoexist)3658 void halbtc8723d2ant_action_wifi_native_lps(IN struct btc_coexist *btcoexist)
3659 {
3660 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
3661 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3662 }
3663
halbtc8723d2ant_action_wifi_multi_port(IN struct btc_coexist * btcoexist)3664 void halbtc8723d2ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
3665 {
3666 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3667 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3668
3669 /* hw all off */
3670 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3671
3672 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3673 }
3674
halbtc8723d2ant_action_wifi_linkscan_process(IN struct btc_coexist * btcoexist)3675 void halbtc8723d2ant_action_wifi_linkscan_process(IN struct btc_coexist *btcoexist)
3676 {
3677 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3678
3679 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
3680 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3681
3682 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3683
3684 if (bt_link_info->pan_exist)
3685 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 22);
3686 else if (bt_link_info->a2dp_exist)
3687 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 16);
3688 else
3689 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 21);
3690 }
3691
halbtc8723d2ant_action_wifi_not_connected(IN struct btc_coexist * btcoexist)3692 void halbtc8723d2ant_action_wifi_not_connected(IN struct btc_coexist *btcoexist)
3693 {
3694 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3695 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3696
3697 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3698
3699 /* fw all off */
3700 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3701 }
3702
halbtc8723d2ant_action_wifi_connected(IN struct btc_coexist * btcoexist)3703 void halbtc8723d2ant_action_wifi_connected(IN struct btc_coexist *btcoexist)
3704 {
3705 switch (coex_dm->cur_algorithm) {
3706
3707 case BT_8723D_2ANT_COEX_ALGO_SCO:
3708 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3709 "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
3710 BTC_TRACE(trace_buf);
3711 halbtc8723d2ant_action_sco(btcoexist);
3712 break;
3713 case BT_8723D_2ANT_COEX_ALGO_HID:
3714 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3715 "[BTCoex], Action 2-Ant, algorithm = HID.\n");
3716 BTC_TRACE(trace_buf);
3717 halbtc8723d2ant_action_hid(btcoexist);
3718 break;
3719 case BT_8723D_2ANT_COEX_ALGO_A2DP:
3720 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3721 "[BTCoex], Action 2-Ant, algorithm = A2DP.\n");
3722 BTC_TRACE(trace_buf);
3723 halbtc8723d2ant_action_a2dp(btcoexist);
3724 break;
3725 case BT_8723D_2ANT_COEX_ALGO_A2DPSINK:
3726 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3727 "[BTCoex], Action 2-Ant, algorithm = A2DP Sink.\n");
3728 BTC_TRACE(trace_buf);
3729 halbtc8723d2ant_action_a2dpsink(btcoexist);
3730 break;
3731 case BT_8723D_2ANT_COEX_ALGO_A2DP_PANHS:
3732 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3733 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
3734 BTC_TRACE(trace_buf);
3735 halbtc8723d2ant_action_a2dp_pan_hs(btcoexist);
3736 break;
3737 case BT_8723D_2ANT_COEX_ALGO_PANEDR:
3738 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3739 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n");
3740 BTC_TRACE(trace_buf);
3741 halbtc8723d2ant_action_pan_edr(btcoexist);
3742 break;
3743 case BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP:
3744 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3745 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n");
3746 BTC_TRACE(trace_buf);
3747 halbtc8723d2ant_action_pan_edr_a2dp(btcoexist);
3748 break;
3749 case BT_8723D_2ANT_COEX_ALGO_PANEDR_HID:
3750 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3751 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
3752 BTC_TRACE(trace_buf);
3753 halbtc8723d2ant_action_pan_edr_hid(btcoexist);
3754 break;
3755 case BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3756 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3757 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
3758 BTC_TRACE(trace_buf);
3759 halbtc8723d2ant_action_hid_a2dp_pan_edr(
3760 btcoexist);
3761 break;
3762 case BT_8723D_2ANT_COEX_ALGO_HID_A2DP:
3763 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3764 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n");
3765 BTC_TRACE(trace_buf);
3766 halbtc8723d2ant_action_hid_a2dp(btcoexist);
3767 break;
3768 case BT_8723D_2ANT_COEX_ALGO_NOPROFILEBUSY:
3769 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3770 "[BTCoex], Action 2-Ant, algorithm = No-Profile busy.\n");
3771 BTC_TRACE(trace_buf);
3772 halbtc8723d2ant_action_bt_idle(btcoexist);
3773 break;
3774 default:
3775 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3776 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3777 BTC_TRACE(trace_buf);
3778 halbtc8723d2ant_action_coex_all_off(btcoexist);
3779 break;
3780 }
3781
3782 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3783
3784 }
3785
3786
halbtc8723d2ant_run_coexist_mechanism(IN struct btc_coexist * btcoexist)3787 void halbtc8723d2ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
3788 {
3789 u8 algorithm = 0;
3790 u32 num_of_wifi_link = 0;
3791 u32 wifi_link_status = 0;
3792 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3793 boolean miracast_plus_bt = FALSE;
3794 boolean scan = FALSE, link = FALSE, roam = FALSE,
3795 under_4way = FALSE,
3796 wifi_connected = FALSE, wifi_under_5g = FALSE,
3797 bt_hs_on = FALSE;
3798
3799 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3800 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3801 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3802 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3803 &under_4way);
3804
3805 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3806 "[BTCoex], RunCoexistMechanism()===>\n");
3807 BTC_TRACE(trace_buf);
3808
3809 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3810 "[BTCoex], under_lps = %d, force_lps_ctrl = %d, acl_busy = %d!!!\n",
3811 coex_sta->under_lps, coex_sta->force_lps_ctrl, coex_sta->acl_busy);
3812 BTC_TRACE(trace_buf);
3813
3814 if (btcoexist->manual_control) {
3815 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3816 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3817 BTC_TRACE(trace_buf);
3818 return;
3819 }
3820
3821 if (btcoexist->stop_coex_dm) {
3822 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3823 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
3824 BTC_TRACE(trace_buf);
3825 return;
3826 }
3827
3828 if (coex_sta->under_ips) {
3829 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3830 "[BTCoex], wifi is under IPS !!!\n");
3831 BTC_TRACE(trace_buf);
3832 return;
3833 }
3834
3835 if (!coex_sta->run_time_state) {
3836 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3837 "[BTCoex], return for run_time_state = FALSE !!!\n");
3838 BTC_TRACE(trace_buf);
3839 return;
3840 }
3841
3842 if (coex_sta->freeze_coexrun_by_btinfo) {
3843 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3844 "[BTCoex], return for freeze_coexrun_by_btinfo\n");
3845 BTC_TRACE(trace_buf);
3846 return;
3847 }
3848
3849 if ((coex_sta->under_lps) && (!coex_sta->force_lps_ctrl) &&
3850 (!coex_sta->acl_busy)) {
3851 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3852 "[BTCoex], RunCoexistMechanism(), wifi is under LPS !!!\n");
3853 BTC_TRACE(trace_buf);
3854 halbtc8723d2ant_action_wifi_native_lps(btcoexist);
3855 return;
3856 }
3857
3858 if (coex_sta->bt_whck_test) {
3859 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3860 "[BTCoex], BT is under WHCK TEST!!!\n");
3861 BTC_TRACE(trace_buf);
3862 halbtc8723d2ant_action_bt_whql_test(btcoexist);
3863 return;
3864 }
3865
3866 if (coex_sta->bt_disabled) {
3867 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3868 "[BTCoex], BT is disabled!!!\n");
3869 BTC_TRACE(trace_buf);
3870 halbtc8723d2ant_action_coex_all_off(btcoexist);
3871 return;
3872 }
3873
3874 if (coex_sta->c2h_bt_inquiry_page) {
3875 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3876 "[BTCoex], BT is under inquiry/page scan !!\n");
3877 BTC_TRACE(trace_buf);
3878 halbtc8723d2ant_action_bt_inquiry(btcoexist);
3879 return;
3880 }
3881
3882 if ((coex_sta->is_setupLink) &&
3883 (coex_sta->bt_relink_downcount != 0)) {
3884 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3885 "[BTCoex], BT is re-link !!!\n");
3886 BTC_TRACE(trace_buf);
3887 halbtc8723d2ant_action_bt_relink(btcoexist);
3888 return;
3889 }
3890
3891 /* for P2P */
3892 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3893 &wifi_link_status);
3894 num_of_wifi_link = wifi_link_status >> 16;
3895
3896 if ((num_of_wifi_link >= 2) ||
3897 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3898 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3899 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3900 num_of_wifi_link, wifi_link_status);
3901 BTC_TRACE(trace_buf);
3902
3903 if (bt_link_info->bt_link_exist)
3904 miracast_plus_bt = TRUE;
3905 else
3906 miracast_plus_bt = FALSE;
3907
3908 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3909 &miracast_plus_bt);
3910
3911 if (scan || link || roam || under_4way) {
3912 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3913 "[BTCoex], scan = %d, link = %d, roam = %d 4way = %d!!!\n",
3914 scan, link, roam, under_4way);
3915 BTC_TRACE(trace_buf);
3916
3917 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3918 "[BTCoex], wifi is under linkscan process + Multi-Port !!\n");
3919 BTC_TRACE(trace_buf);
3920
3921 halbtc8723d2ant_action_wifi_linkscan_process(btcoexist);
3922 } else
3923
3924 halbtc8723d2ant_action_wifi_multi_port(btcoexist);
3925
3926 return;
3927 }
3928
3929 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3930
3931 if (bt_hs_on) {
3932 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3933 "############# [BTCoex], BT Is hs\n");
3934 BTC_TRACE(trace_buf);
3935 halbtc8723d2ant_action_bt_hs(btcoexist);
3936 return;
3937 }
3938
3939 if ((BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3940 coex_dm->bt_status) ||
3941 (BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE ==
3942 coex_dm->bt_status)) {
3943
3944 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3945 "[BTCoex], Action 2-Ant, bt idle!!.\n");
3946 BTC_TRACE(trace_buf);
3947
3948 halbtc8723d2ant_action_bt_idle(btcoexist);
3949 return;
3950 }
3951
3952 algorithm = halbtc8723d2ant_action_algorithm(btcoexist);
3953 coex_dm->cur_algorithm = algorithm;
3954 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Algorithm = %d\n",
3955 coex_dm->cur_algorithm);
3956 BTC_TRACE(trace_buf);
3957
3958 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3959 &wifi_connected);
3960
3961 if (scan || link || roam || under_4way) {
3962 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3963 "[BTCoex], WiFi is under Link Process !!\n");
3964 BTC_TRACE(trace_buf);
3965 halbtc8723d2ant_action_wifi_linkscan_process(btcoexist);
3966 } else if (wifi_connected) {
3967
3968 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3969 "[BTCoex], Action 2-Ant, wifi connected!!.\n");
3970 BTC_TRACE(trace_buf);
3971 halbtc8723d2ant_action_wifi_connected(btcoexist);
3972
3973 } else {
3974
3975 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3976 "[BTCoex], Action 2-Ant, wifi not-connected!!.\n");
3977 BTC_TRACE(trace_buf);
3978 halbtc8723d2ant_action_wifi_not_connected(btcoexist);
3979 }
3980 }
3981
3982
halbtc8723d2ant_init_coex_dm(IN struct btc_coexist * btcoexist)3983 void halbtc8723d2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
3984 {
3985 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3986 "[BTCoex], Coex Mechanism Init!!\n");
3987 BTC_TRACE(trace_buf);
3988
3989 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3990 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3991
3992 /* sw all off */
3993 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, FALSE);
3994
3995 coex_sta->pop_event_cnt = 0;
3996 coex_sta->cnt_RemoteNameReq = 0;
3997 coex_sta->cnt_ReInit = 0;
3998 coex_sta->cnt_setupLink = 0;
3999 coex_sta->cnt_IgnWlanAct = 0;
4000 coex_sta->cnt_Page = 0;
4001 coex_sta->cnt_RoleSwitch = 0;
4002
4003 halbtc8723d2ant_query_bt_info(btcoexist);
4004 }
4005
4006
halbtc8723d2ant_init_hw_config(IN struct btc_coexist * btcoexist,IN boolean wifi_only)4007 void halbtc8723d2ant_init_hw_config(IN struct btc_coexist *btcoexist,
4008 IN boolean wifi_only)
4009 {
4010 u8 u8tmp0 = 0, u8tmp1 = 0;
4011 u32 vendor;
4012 u32 u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
4013 u16 u16tmp1 = 0;
4014 u8 i = 0;
4015
4016
4017 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4018 "[BTCoex], 2Ant Init HW Config!!\n");
4019 BTC_TRACE(trace_buf);
4020
4021 #if BT_8723D_2ANT_COEX_DBG
4022 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
4023 0x38);
4024 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
4025 0x54);
4026 u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
4027 u8tmp1 = btcoexist->btc_read_1byte(btcoexist, 0x73);
4028 u8tmp0 = btcoexist->btc_read_1byte(btcoexist, 0x67);
4029
4030 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4031 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(Before init_hw_config)\n",
4032 u8tmp0, u16tmp1, u8tmp1);
4033 BTC_TRACE(trace_buf);
4034
4035 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4036 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x (Before init_hw_config)\n",
4037 u32tmp1, u32tmp2);
4038 BTC_TRACE(trace_buf);
4039 #endif
4040
4041
4042 coex_sta->bt_coex_supported_feature = 0;
4043 coex_sta->bt_coex_supported_version = 0;
4044 coex_sta->bt_ble_scan_type = 0;
4045 coex_sta->bt_ble_scan_para[0] = 0;
4046 coex_sta->bt_ble_scan_para[1] = 0;
4047 coex_sta->bt_ble_scan_para[2] = 0;
4048 coex_sta->bt_reg_vendor_ac = 0xffff;
4049 coex_sta->bt_reg_vendor_ae = 0xffff;
4050 coex_sta->gnt_error_cnt = 0;
4051 coex_sta->bt_relink_downcount = 0;
4052 coex_sta->wl_rx_rate = BTC_UNKNOWN;
4053
4054 for (i = 0; i <= 9; i++)
4055 coex_sta->bt_afh_map[i] = 0;
4056
4057 #if 0
4058 btcoexist->btc_get(btcoexist, BTC_GET_U4_VENDOR, &vendor);
4059 if (vendor == BTC_VENDOR_LENOVO)
4060 coex_dm->switch_thres_offset = 0;
4061 else
4062 coex_dm->switch_thres_offset = 20;
4063 #endif
4064 /* 0xf0[15:12] --> Chip Cut information */
4065 coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
4066 0xf1) & 0xf0) >> 4;
4067
4068 coex_sta->dis_ver_info_cnt = 0;
4069
4070 /* default isolation = 15dB */
4071 coex_sta->isolation_btween_wb = BT_8723D_2ANT_DEFAULT_ISOLATION;
4072 halbtc8723d2ant_coex_switch_threshold(btcoexist,
4073 coex_sta->isolation_btween_wb);
4074
4075 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
4076 0x1); /* enable TBTT nterrupt */
4077
4078 /* BT report packet sample rate */
4079 btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
4080
4081 /* Init 0x778 = 0x1 for 2-Ant */
4082 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
4083
4084 /* Enable PTA (3-wire function form BT side) */
4085 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
4086 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x41, 0x02, 0x1);
4087
4088 /* Enable PTA (tx/rx signal form WiFi side) */
4089 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4c6, 0x10, 0x1);
4090
4091 halbtc8723d2ant_enable_gnt_to_gpio(btcoexist, TRUE);
4092
4093 #if 0
4094 /* check if WL firmware download ok */
4095 if (btcoexist->btc_read_1byte(btcoexist, 0x80) == 0xc6)
4096 halbtc8723d2ant_post_state_to_bt(btcoexist,
4097 BT_8723D_2ANT_SCOREBOARD_ONOFF, TRUE);
4098 #endif
4099
4100 /* Enable counter statistics */
4101 btcoexist->btc_write_1byte(btcoexist, 0x76e,
4102 0x4); /* 0x76e[3] =1, WLAN_Act control by PTA */
4103
4104 /* WLAN_Tx by GNT_WL 0x950[29] = 0 */
4105 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x20, 0x0);
4106
4107 psd_scan->ant_det_is_ant_det_available = TRUE;
4108
4109 if (coex_sta->is_rf_state_off) {
4110
4111 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4112 FORCE_EXEC,
4113 BT_8723D_2ANT_PHASE_WLAN_OFF);
4114
4115 btcoexist->stop_coex_dm = TRUE;
4116
4117 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4118 "[BTCoex], ********** halbtc8723d2ant_init_hw_config (RF Off)**********\n");
4119 BTC_TRACE(trace_buf);
4120 } else if (wifi_only) {
4121 coex_sta->concurrent_rx_mode_on = FALSE;
4122 /* Path config */
4123 /* Set Antenna Path */
4124 halbtc8723d2ant_set_ant_path(btcoexist,
4125 BTC_ANT_PATH_AUTO,
4126 FORCE_EXEC,
4127 BT_8723D_2ANT_PHASE_WLANONLY_INIT);
4128
4129 btcoexist->stop_coex_dm = TRUE;
4130 } else {
4131 /*Set BT polluted packet on for Tx rate adaptive not including Tx retry break by PTA, 0x45c[19] =1 */
4132 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x45e, 0x8, 0x1);
4133
4134 coex_sta->concurrent_rx_mode_on = TRUE;
4135 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x2, 0x1); */
4136
4137 /* RF 0x1[0] = 0->Set GNT_WL_RF_Rx always = 1 for con-current Rx */
4138 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0x1, 0x0);
4139
4140 /* Path config */
4141 halbtc8723d2ant_set_ant_path(btcoexist,
4142 BTC_ANT_PATH_AUTO,
4143 FORCE_EXEC,
4144 BT_8723D_2ANT_PHASE_COEX_INIT);
4145
4146 btcoexist->stop_coex_dm = FALSE;
4147 }
4148
4149 halbtc8723d2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
4150
4151 halbtc8723d2ant_ps_tdma(btcoexist, FORCE_EXEC, FALSE, 0);
4152 }
4153
halbtc8723d2ant_psd_log2base(IN struct btc_coexist * btcoexist,IN u32 val)4154 u32 halbtc8723d2ant_psd_log2base(IN struct btc_coexist *btcoexist, IN u32 val)
4155 {
4156 u8 j;
4157 u32 tmp, tmp2, val_integerd_b = 0, tindex, shiftcount = 0;
4158 u32 result, val_fractiond_b = 0, table_fraction[21] = {0, 432, 332, 274, 232, 200,
4159 174, 151, 132, 115, 100, 86, 74, 62, 51, 42,
4160 32, 23, 15, 7, 0
4161 };
4162
4163 if (val == 0)
4164 return 0;
4165
4166 tmp = val;
4167
4168 while (1) {
4169 if (tmp == 1)
4170 break;
4171 else {
4172 tmp = (tmp >> 1);
4173 shiftcount++;
4174 }
4175 }
4176
4177
4178 val_integerd_b = shiftcount + 1;
4179
4180 tmp2 = 1;
4181 for (j = 1; j <= val_integerd_b; j++)
4182 tmp2 = tmp2 * 2;
4183
4184 tmp = (val * 100) / tmp2;
4185 tindex = tmp / 5;
4186
4187 if (tindex > 20)
4188 tindex = 20;
4189
4190 val_fractiond_b = table_fraction[tindex];
4191
4192 result = val_integerd_b * 100 - val_fractiond_b;
4193
4194 return result;
4195
4196
4197 }
4198
halbtc8723d2ant_psd_show_antenna_detect_result(IN struct btc_coexist * btcoexist)4199 void halbtc8723d2ant_psd_show_antenna_detect_result(IN struct btc_coexist
4200 *btcoexist)
4201 {
4202 u8 *cli_buf = btcoexist->cli_buf;
4203 struct btc_board_info *board_info = &btcoexist->board_info;
4204
4205 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4206 "\r\n============[Antenna Detection info] ============\n");
4207 CL_PRINTF(cli_buf);
4208
4209 if (psd_scan->ant_det_result == 12) { /* Get Ant Det from BT */
4210
4211 if (board_info->btdm_ant_num_by_ant_det == 1)
4212 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4213 "\r\n %-35s = %s (%d~%d)",
4214 "Ant Det Result", "1-Antenna",
4215 BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT,
4216 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION);
4217 else {
4218
4219 if (psd_scan->ant_det_psd_scan_peak_val >
4220 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
4221 * 100)
4222 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4223 "\r\n %-35s = %s (>%d)",
4224 "Ant Det Result", "2-Antenna (Bad-Isolation)",
4225 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4226 else
4227 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4228 "\r\n %-35s = %s (%d~%d)",
4229 "Ant Det Result", "2-Antenna (Good-Isolation)",
4230 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4231 + psd_scan->ant_det_thres_offset,
4232 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4233 }
4234
4235 } else if (psd_scan->ant_det_result == 1)
4236 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (>%d)",
4237 "Ant Det Result", "2-Antenna (Bad-Isolation)",
4238 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4239 else if (psd_scan->ant_det_result == 2)
4240 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
4241 "Ant Det Result", "2-Antenna (Good-Isolation)",
4242 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4243 + psd_scan->ant_det_thres_offset,
4244 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4245 else
4246 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
4247 "Ant Det Result", "1-Antenna",
4248 BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT,
4249 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4250 + psd_scan->ant_det_thres_offset);
4251
4252 CL_PRINTF(cli_buf);
4253
4254 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s ",
4255 "Antenna Detection Finish",
4256 (board_info->btdm_ant_det_finish
4257 ? "Yes" : "No"));
4258 CL_PRINTF(cli_buf);
4259
4260 switch (psd_scan->ant_det_result) {
4261 case 0:
4262 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4263 "(BT is not available)");
4264 break;
4265 case 1: /* 2-Ant bad-isolation */
4266 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4267 "(BT is available)");
4268 break;
4269 case 2: /* 2-Ant good-isolation */
4270 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4271 "(BT is available)");
4272 break;
4273 case 3: /* 1-Ant */
4274 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4275 "(BT is available)");
4276 break;
4277 case 4:
4278 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4279 "(Uncertainty result)");
4280 break;
4281 case 5:
4282 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "(Pre-Scan fai)");
4283 break;
4284 case 6:
4285 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4286 "(WiFi is Scanning)");
4287 break;
4288 case 7:
4289 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4290 "(BT is not idle)");
4291 break;
4292 case 8:
4293 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4294 "(Abort by WiFi Scanning)");
4295 break;
4296 case 9:
4297 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4298 "(Antenna Init is not ready)");
4299 break;
4300 case 10:
4301 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4302 "(BT is Inquiry or page)");
4303 break;
4304 case 11:
4305 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4306 "(BT is Disabled)");
4307 case 12:
4308 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4309 "(BT is available, result from BT");
4310 break;
4311 }
4312 CL_PRINTF(cli_buf);
4313
4314 if (psd_scan->ant_det_result == 12) {
4315 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
4316 "PSD Scan Peak Value",
4317 psd_scan->ant_det_psd_scan_peak_val / 100);
4318 CL_PRINTF(cli_buf);
4319 return;
4320 }
4321
4322 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4323 "Ant Detect Total Count", psd_scan->ant_det_try_count);
4324 CL_PRINTF(cli_buf);
4325
4326 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4327 "Ant Detect Fail Count", psd_scan->ant_det_fail_count);
4328 CL_PRINTF(cli_buf);
4329
4330 if ((!board_info->btdm_ant_det_finish) &&
4331 (psd_scan->ant_det_result != 5))
4332 return;
4333
4334 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT Response",
4335 (psd_scan->ant_det_result ? "ok" : "fail"));
4336 CL_PRINTF(cli_buf);
4337
4338 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ms", "BT Tx Time",
4339 psd_scan->ant_det_bt_tx_time);
4340 CL_PRINTF(cli_buf);
4341
4342 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d", "BT Tx Ch",
4343 psd_scan->ant_det_bt_le_channel);
4344 CL_PRINTF(cli_buf);
4345
4346 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
4347 "WiFi PSD Cent-Ch/Offset/Span",
4348 psd_scan->real_cent_freq, psd_scan->real_offset,
4349 psd_scan->real_span);
4350 CL_PRINTF(cli_buf);
4351
4352 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
4353 "PSD Pre-Scan Peak Value",
4354 psd_scan->ant_det_pre_psdscan_peak_val / 100);
4355 CL_PRINTF(cli_buf);
4356
4357 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (<= %d)",
4358 "PSD Pre-Scan result",
4359 (psd_scan->ant_det_result != 5 ? "ok" : "fail"),
4360 BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
4361 + psd_scan->ant_det_thres_offset);
4362 CL_PRINTF(cli_buf);
4363
4364 if (psd_scan->ant_det_result == 5)
4365 return;
4366
4367 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s dB",
4368 "PSD Scan Peak Value", psd_scan->ant_det_peak_val);
4369 CL_PRINTF(cli_buf);
4370
4371 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s MHz",
4372 "PSD Scan Peak Freq", psd_scan->ant_det_peak_freq);
4373 CL_PRINTF(cli_buf);
4374
4375
4376 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "TFBGA Package",
4377 (board_info->tfbga_package) ? "Yes" : "No");
4378 CL_PRINTF(cli_buf);
4379
4380 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4381 "PSD Threshold Offset", psd_scan->ant_det_thres_offset);
4382 CL_PRINTF(cli_buf);
4383
4384 }
4385
halbtc8723d2ant_psd_showdata(IN struct btc_coexist * btcoexist)4386 void halbtc8723d2ant_psd_showdata(IN struct btc_coexist *btcoexist)
4387 {
4388 u8 *cli_buf = btcoexist->cli_buf;
4389 u32 delta_freq_per_point;
4390 u32 freq, freq1, freq2, n = 0, i = 0, j = 0, m = 0, psd_rep1, psd_rep2;
4391
4392 if (psd_scan->ant_det_result == 12)
4393 return;
4394
4395 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4396 "\r\n\n============[PSD info] (%d)============\n",
4397 psd_scan->psd_gen_count);
4398 CL_PRINTF(cli_buf);
4399
4400 if (psd_scan->psd_gen_count == 0) {
4401 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n No data !!\n");
4402 CL_PRINTF(cli_buf);
4403 return;
4404 }
4405
4406 if (psd_scan->psd_point == 0)
4407 delta_freq_per_point = 0;
4408 else
4409 delta_freq_per_point = psd_scan->psd_band_width /
4410 psd_scan->psd_point;
4411
4412 /* if (psd_scan->is_psd_show_max_only) */
4413 if (0) {
4414 psd_rep1 = psd_scan->psd_max_value / 100;
4415 psd_rep2 = psd_scan->psd_max_value - psd_rep1 * 100;
4416
4417 freq = ((psd_scan->real_cent_freq - 20) * 1000000 +
4418 psd_scan->psd_max_value_point * delta_freq_per_point);
4419 freq1 = freq / 1000000;
4420 freq2 = freq / 1000 - freq1 * 1000;
4421
4422 if (freq2 < 100)
4423 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4424 "\r\n Freq = %d.0%d MHz",
4425 freq1, freq2);
4426 else
4427 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4428 "\r\n Freq = %d.%d MHz",
4429 freq1, freq2);
4430
4431 if (psd_rep2 < 10)
4432 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4433 ", Value = %d.0%d dB, (%d)\n",
4434 psd_rep1, psd_rep2, psd_scan->psd_max_value);
4435 else
4436 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4437 ", Value = %d.%d dB, (%d)\n",
4438 psd_rep1, psd_rep2, psd_scan->psd_max_value);
4439
4440 CL_PRINTF(cli_buf);
4441 } else {
4442 m = psd_scan->psd_start_point;
4443 n = psd_scan->psd_start_point;
4444 i = 1;
4445 j = 1;
4446
4447 while (1) {
4448 do {
4449 freq = ((psd_scan->real_cent_freq - 20) *
4450 1000000 + m *
4451 delta_freq_per_point);
4452 freq1 = freq / 1000000;
4453 freq2 = freq / 1000 - freq1 * 1000;
4454
4455 if (i == 1) {
4456 if (freq2 == 0)
4457 CL_SPRINTF(cli_buf,
4458 BT_TMP_BUF_SIZE,
4459 "\r\n Freq%6d.000",
4460 freq1);
4461 else if (freq2 < 100)
4462 CL_SPRINTF(cli_buf,
4463 BT_TMP_BUF_SIZE,
4464 "\r\n Freq%6d.0%2d",
4465 freq1,
4466 freq2);
4467 else
4468 CL_SPRINTF(cli_buf,
4469 BT_TMP_BUF_SIZE,
4470 "\r\n Freq%6d.%3d",
4471 freq1,
4472 freq2);
4473 } else if ((i % 8 == 0) ||
4474 (m == psd_scan->psd_stop_point)) {
4475 if (freq2 == 0)
4476 CL_SPRINTF(cli_buf,
4477 BT_TMP_BUF_SIZE,
4478 "%6d.000\n", freq1);
4479 else if (freq2 < 100)
4480 CL_SPRINTF(cli_buf,
4481 BT_TMP_BUF_SIZE,
4482 "%6d.0%2d\n", freq1,
4483 freq2);
4484 else
4485 CL_SPRINTF(cli_buf,
4486 BT_TMP_BUF_SIZE,
4487 "%6d.%3d\n", freq1,
4488 freq2);
4489 } else {
4490 if (freq2 == 0)
4491 CL_SPRINTF(cli_buf,
4492 BT_TMP_BUF_SIZE,
4493 "%6d.000", freq1);
4494 else if (freq2 < 100)
4495 CL_SPRINTF(cli_buf,
4496 BT_TMP_BUF_SIZE,
4497 "%6d.0%2d", freq1,
4498 freq2);
4499 else
4500 CL_SPRINTF(cli_buf,
4501 BT_TMP_BUF_SIZE,
4502 "%6d.%3d", freq1,
4503 freq2);
4504 }
4505
4506 i++;
4507 m++;
4508 CL_PRINTF(cli_buf);
4509
4510 } while ((i <= 8) && (m <= psd_scan->psd_stop_point));
4511
4512
4513 do {
4514 psd_rep1 = psd_scan->psd_report_max_hold[n] /
4515 100;
4516 psd_rep2 = psd_scan->psd_report_max_hold[n] -
4517 psd_rep1 *
4518 100;
4519
4520 if (j == 1) {
4521 if (psd_rep2 < 10)
4522 CL_SPRINTF(cli_buf,
4523 BT_TMP_BUF_SIZE,
4524 "\r\n Val %7d.0%d",
4525 psd_rep1,
4526 psd_rep2);
4527 else
4528 CL_SPRINTF(cli_buf,
4529 BT_TMP_BUF_SIZE,
4530 "\r\n Val %7d.%d",
4531 psd_rep1,
4532 psd_rep2);
4533 } else if ((j % 8 == 0) ||
4534 (n == psd_scan->psd_stop_point)) {
4535 if (psd_rep2 < 10)
4536 CL_SPRINTF(cli_buf,
4537 BT_TMP_BUF_SIZE,
4538 "%7d.0%d\n", psd_rep1,
4539 psd_rep2);
4540 else
4541 CL_SPRINTF(cli_buf,
4542 BT_TMP_BUF_SIZE,
4543 "%7d.%d\n", psd_rep1,
4544 psd_rep2);
4545 } else {
4546 if (psd_rep2 < 10)
4547 CL_SPRINTF(cli_buf,
4548 BT_TMP_BUF_SIZE,
4549 "%7d.0%d", psd_rep1,
4550 psd_rep2);
4551 else
4552 CL_SPRINTF(cli_buf,
4553 BT_TMP_BUF_SIZE,
4554 "%7d.%d", psd_rep1,
4555 psd_rep2);
4556 }
4557
4558 j++;
4559 n++;
4560 CL_PRINTF(cli_buf);
4561
4562 } while ((j <= 8) && (n <= psd_scan->psd_stop_point));
4563
4564 if ((m > psd_scan->psd_stop_point) ||
4565 (n > psd_scan->psd_stop_point))
4566 break;
4567 else {
4568 i = 1;
4569 j = 1;
4570 }
4571
4572 }
4573 }
4574
4575
4576 }
4577
4578 #ifdef PLATFORM_WINDOWS
4579 #pragma optimize("", off)
4580 #endif
halbtc8723d2ant_psd_maxholddata(IN struct btc_coexist * btcoexist,IN u32 gen_count)4581 void halbtc8723d2ant_psd_maxholddata(IN struct btc_coexist *btcoexist,
4582 IN u32 gen_count)
4583 {
4584 u32 i = 0;
4585 u32 loop_i_max = 0, loop_val_max = 0;
4586
4587 if (gen_count == 1) {
4588 memcpy(psd_scan->psd_report_max_hold,
4589 psd_scan->psd_report,
4590 BT_8723D_2ANT_ANTDET_PSD_POINTS * sizeof(u32));
4591 }
4592
4593 for (i = psd_scan->psd_start_point;
4594 i <= psd_scan->psd_stop_point; i++) {
4595
4596 /* update max-hold value at each freq point */
4597 if (psd_scan->psd_report[i] > psd_scan->psd_report_max_hold[i])
4598 psd_scan->psd_report_max_hold[i] =
4599 psd_scan->psd_report[i];
4600
4601 /* search the max value in this seep */
4602 if (psd_scan->psd_report[i] > loop_val_max) {
4603 loop_val_max = psd_scan->psd_report[i];
4604 loop_i_max = i;
4605 }
4606 }
4607
4608 if (gen_count <= BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT)
4609 psd_scan->psd_loop_max_value[gen_count - 1] = loop_val_max;
4610
4611 }
4612
4613
4614 #ifdef PLATFORM_WINDOWS
4615 #pragma optimize("", off)
4616 #endif
halbtc8723d2ant_psd_getdata(IN struct btc_coexist * btcoexist,IN u32 point)4617 u32 halbtc8723d2ant_psd_getdata(IN struct btc_coexist *btcoexist, IN u32 point)
4618 {
4619 /* reg 0x808[9:0]: FFT data x */
4620 /* reg 0x808[22]: 0-->1 to get 1 FFT data y */
4621 /* reg 0x8b4[15:0]: FFT data y report */
4622
4623 u32 val = 0, psd_report = 0;
4624 int k = 0;
4625
4626 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4627
4628 val &= 0xffbffc00;
4629 val |= point;
4630
4631 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4632
4633 val |= 0x00400000;
4634 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4635
4636 while (1) {
4637 if (k++ > BT_8723D_2ANT_ANTDET_SWEEPPOINT_DELAY)
4638 break;
4639 }
4640
4641 val = btcoexist->btc_read_4byte(btcoexist, 0x8b4);
4642
4643 psd_report = val & 0x0000ffff;
4644
4645 return psd_report;
4646 }
4647
4648 #ifdef PLATFORM_WINDOWS
4649 #pragma optimize("", off)
4650 #endif
halbtc8723d2ant_psd_sweep_point(IN struct btc_coexist * btcoexist,IN u32 cent_freq,IN s32 offset,IN u32 span,IN u32 points,IN u32 avgnum,IN u32 loopcnt)4651 boolean halbtc8723d2ant_psd_sweep_point(IN struct btc_coexist *btcoexist,
4652 IN u32 cent_freq, IN s32 offset, IN u32 span, IN u32 points,
4653 IN u32 avgnum, IN u32 loopcnt)
4654 {
4655 u32 i = 0, val = 0, n = 0, k = 0, j, point_index = 0;
4656 u32 points1 = 0, psd_report = 0;
4657 u32 start_p = 0, stop_p = 0, delta_freq_per_point = 156250;
4658 u32 psd_center_freq = 20 * 10 ^ 6;
4659 boolean outloop = FALSE, scan, roam, is_sweep_ok = TRUE;
4660 u8 flag = 0;
4661 u32 tmp = 0, u32tmp1 = 0;
4662 u32 wifi_original_channel = 1;
4663 u32 psd_sum = 0, avg_cnt = 0;
4664 u32 i_max = 0, val_max = 0, val_max2 = 0;
4665
4666 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4667 "xxxxxxxxxxxxxxxx PSD Sweep Start!!\n");
4668 BTC_TRACE(trace_buf);
4669
4670 do {
4671 switch (flag) {
4672 case 0: /* Get PSD parameters */
4673 default:
4674
4675 psd_scan->psd_band_width = 40 * 1000000;
4676 psd_scan->psd_point = points;
4677 psd_scan->psd_start_base = points / 2;
4678 psd_scan->psd_avg_num = avgnum;
4679 psd_scan->real_cent_freq = cent_freq;
4680 psd_scan->real_offset = offset;
4681 psd_scan->real_span = span;
4682
4683
4684 points1 = psd_scan->psd_point;
4685 delta_freq_per_point = psd_scan->psd_band_width /
4686 psd_scan->psd_point;
4687
4688 /* PSD point setup */
4689 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4690 val &= 0xffff0fff;
4691
4692 switch (psd_scan->psd_point) {
4693 case 128:
4694 val |= 0x0;
4695 break;
4696 case 256:
4697 default:
4698 val |= 0x00004000;
4699 break;
4700 case 512:
4701 val |= 0x00008000;
4702 break;
4703 case 1024:
4704 val |= 0x0000c000;
4705 break;
4706 }
4707
4708 switch (psd_scan->psd_avg_num) {
4709 case 1:
4710 val |= 0x0;
4711 break;
4712 case 8:
4713 val |= 0x00001000;
4714 break;
4715 case 16:
4716 val |= 0x00002000;
4717 break;
4718 case 32:
4719 default:
4720 val |= 0x00003000;
4721 break;
4722 }
4723 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4724
4725 flag = 1;
4726 break;
4727 case 1: /* calculate the PSD point index from freq/offset/span */
4728 psd_center_freq = psd_scan->psd_band_width / 2 +
4729 offset * (1000000);
4730
4731 start_p = psd_scan->psd_start_base + (psd_center_freq -
4732 span * (1000000) / 2) / delta_freq_per_point;
4733 psd_scan->psd_start_point = start_p -
4734 psd_scan->psd_start_base;
4735
4736 stop_p = psd_scan->psd_start_base + (psd_center_freq +
4737 span * (1000000) / 2) / delta_freq_per_point;
4738 psd_scan->psd_stop_point = stop_p -
4739 psd_scan->psd_start_base - 1;
4740
4741 flag = 2;
4742 break;
4743 case 2: /* set RF channel/BW/Mode */
4744
4745 /* set 3-wire off */
4746 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
4747 val |= 0x00300000;
4748 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
4749
4750 /* CCK off */
4751 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
4752 val &= 0xfeffffff;
4753 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
4754
4755 /* Tx-pause on */
4756 btcoexist->btc_write_1byte(btcoexist, 0x522, 0x6f);
4757
4758 /* store WiFi original channel */
4759 wifi_original_channel = btcoexist->btc_get_rf_reg(
4760 btcoexist, BTC_RF_A, 0x18, 0x3ff);
4761
4762 /* Set RF channel */
4763 if (cent_freq == 2484)
4764 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
4765 0x18, 0x3ff, 0xe);
4766 else
4767 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
4768 0x18, 0x3ff, (cent_freq - 2412) / 5 +
4769 1); /* WiFi TRx Mask on */
4770
4771 /* save original RCK value */
4772 u32tmp1 = btcoexist->btc_get_rf_reg(
4773 btcoexist, BTC_RF_A, 0x1d, 0xfffff);
4774
4775 /* Enter debug mode */
4776 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xde,
4777 0x2, 0x1);
4778
4779 /* Set RF Rx filter corner */
4780 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1d,
4781 0xfffff, 0x2e);
4782
4783
4784 /* Set RF mode = Rx, RF Gain = 0x320a0 */
4785 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x0,
4786 0xfffff, 0x320a0);
4787
4788 while (1) {
4789 if (k++ > BT_8723D_2ANT_ANTDET_SWEEPPOINT_DELAY)
4790 break;
4791 }
4792 flag = 3;
4793 break;
4794 case 3:
4795 psd_scan->psd_gen_count = 0;
4796 for (j = 1; j <= loopcnt; j++) {
4797
4798 btcoexist->btc_get(btcoexist,
4799 BTC_GET_BL_WIFI_SCAN, &scan);
4800 btcoexist->btc_get(btcoexist,
4801 BTC_GET_BL_WIFI_ROAM, &roam);
4802
4803 if (scan || roam) {
4804 is_sweep_ok = FALSE;
4805 break;
4806 }
4807 memset(psd_scan->psd_report, 0,
4808 psd_scan->psd_point * sizeof(u32));
4809 start_p = psd_scan->psd_start_point +
4810 psd_scan->psd_start_base;
4811 stop_p = psd_scan->psd_stop_point +
4812 psd_scan->psd_start_base + 1;
4813
4814 i = start_p;
4815 point_index = 0;
4816
4817 while (i < stop_p) {
4818 if (i >= points1)
4819 psd_report =
4820 halbtc8723d2ant_psd_getdata(
4821 btcoexist, i - points1);
4822 else
4823 psd_report =
4824 halbtc8723d2ant_psd_getdata(
4825 btcoexist, i);
4826
4827 if (psd_report == 0)
4828 tmp = 0;
4829 else
4830 /* tmp = 20*log10((double)psd_report); */
4831 /* 20*log2(x)/log2(10), log2Base return theresult of the psd_report*100 */
4832 tmp = 6 * halbtc8723d2ant_psd_log2base(
4833 btcoexist, psd_report);
4834
4835 n = i - psd_scan->psd_start_base;
4836 psd_scan->psd_report[n] = tmp;
4837
4838 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4839 "Point=%d, psd_dB_data = %d\n",
4840 i, psd_scan->psd_report[n]);
4841 BTC_TRACE(trace_buf);
4842
4843 i++;
4844
4845 }
4846
4847 halbtc8723d2ant_psd_maxholddata(btcoexist, j);
4848
4849 psd_scan->psd_gen_count = j;
4850
4851 /*Accumulate Max PSD value in this loop if the value > threshold */
4852 if (psd_scan->psd_loop_max_value[j - 1] >=
4853 4000) {
4854 psd_sum = psd_sum +
4855 psd_scan->psd_loop_max_value[j -
4856 1];
4857 avg_cnt++;
4858 }
4859
4860 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4861 "Loop=%d, Max_dB_data = %d\n",
4862 j, psd_scan->psd_loop_max_value[j
4863 - 1]);
4864 BTC_TRACE(trace_buf);
4865
4866 }
4867
4868 if (loopcnt == BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT) {
4869
4870 /* search the Max Value between each-freq-point-max-hold value of all sweep*/
4871 for (i = 1;
4872 i <= BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT;
4873 i++) {
4874
4875 if (i == 1) {
4876 i_max = i;
4877 val_max = psd_scan->psd_loop_max_value[i
4878 - 1];
4879 val_max2 =
4880 psd_scan->psd_loop_max_value[i
4881 - 1];
4882 } else if (
4883 psd_scan->psd_loop_max_value[i -
4884 1] > val_max) {
4885 val_max2 = val_max;
4886 i_max = i;
4887 val_max = psd_scan->psd_loop_max_value[i
4888 - 1];
4889 } else if (
4890 psd_scan->psd_loop_max_value[i -
4891 1] > val_max2)
4892 val_max2 =
4893 psd_scan->psd_loop_max_value[i
4894 - 1];
4895
4896 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4897 "i = %d, val_hold= %d, val_max = %d, val_max2 = %d\n",
4898 i, psd_scan->psd_loop_max_value[i
4899 - 1],
4900 val_max, val_max2);
4901
4902 BTC_TRACE(trace_buf);
4903 }
4904
4905 psd_scan->psd_max_value_point = i_max;
4906 psd_scan->psd_max_value = val_max;
4907 psd_scan->psd_max_value2 = val_max2;
4908
4909 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4910 "val_max = %d, val_max2 = %d\n",
4911 psd_scan->psd_max_value,
4912 psd_scan->psd_max_value2);
4913 BTC_TRACE(trace_buf);
4914 }
4915
4916 if (avg_cnt != 0) {
4917 psd_scan->psd_avg_value = (psd_sum / avg_cnt);
4918 if ((psd_sum % avg_cnt) >= (avg_cnt / 2))
4919 psd_scan->psd_avg_value++;
4920 } else
4921 psd_scan->psd_avg_value = 0;
4922
4923 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4924 "AvgLoop=%d, Avg_dB_data = %d\n",
4925 avg_cnt, psd_scan->psd_avg_value);
4926 BTC_TRACE(trace_buf);
4927
4928 flag = 100;
4929 break;
4930 case 99: /* error */
4931
4932 outloop = TRUE;
4933 break;
4934 case 100: /* recovery */
4935
4936 /* set 3-wire on */
4937 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
4938 val &= 0xffcfffff;
4939 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
4940
4941 /* CCK on */
4942 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
4943 val |= 0x01000000;
4944 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
4945
4946 /* Tx-pause off */
4947 btcoexist->btc_write_1byte(btcoexist, 0x522, 0x0);
4948
4949 /* PSD off */
4950 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4951 val &= 0xffbfffff;
4952 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4953
4954 /* restore RF Rx filter corner */
4955 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1d,
4956 0xfffff, u32tmp1);
4957
4958 /* Exit debug mode */
4959 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xde,
4960 0x2, 0x0);
4961
4962 /* restore WiFi original channel */
4963 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x18,
4964 0x3ff, wifi_original_channel);
4965
4966 outloop = TRUE;
4967 break;
4968
4969 }
4970
4971 } while (!outloop);
4972
4973 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4974 "xxxxxxxxxxxxxxxx PSD Sweep Stop!!\n");
4975 BTC_TRACE(trace_buf);
4976 return is_sweep_ok;
4977
4978 }
4979
4980 #ifdef PLATFORM_WINDOWS
4981 #pragma optimize("", off)
4982 #endif
halbtc8723d2ant_psd_antenna_detection(IN struct btc_coexist * btcoexist)4983 boolean halbtc8723d2ant_psd_antenna_detection(IN struct btc_coexist
4984 *btcoexist)
4985 {
4986 u32 i = 0;
4987 u32 wlpsd_cent_freq = 2484, wlpsd_span = 2;
4988 s32 wlpsd_offset = -4;
4989 u32 bt_tx_time, bt_le_channel;
4990 u8 bt_le_ch[13] = {3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 33};
4991
4992 u8 h2c_parameter[3] = {0}, u8tmpa, u8tmpb;
4993
4994 u8 state = 0;
4995 boolean outloop = FALSE, bt_resp = FALSE, ant_det_finish = FALSE;
4996 u32 freq, freq1, freq2, psd_rep1, psd_rep2, delta_freq_per_point,
4997 u32tmp, u32tmp0, u32tmp1, u32tmp2 ;
4998 struct btc_board_info *board_info = &btcoexist->board_info;
4999
5000 memset(psd_scan->ant_det_peak_val, 0, 16 * sizeof(u8));
5001 memset(psd_scan->ant_det_peak_freq, 0, 16 * sizeof(u8));
5002
5003 psd_scan->ant_det_bt_tx_time =
5004 BT_8723D_2ANT_ANTDET_BTTXTIME; /* 0.42ms*50 = 20ms (0.42ms = 1 PSD sweep) */
5005 psd_scan->ant_det_bt_le_channel = BT_8723D_2ANT_ANTDET_BTTXCHANNEL;
5006
5007 bt_tx_time = psd_scan->ant_det_bt_tx_time;
5008 bt_le_channel = psd_scan->ant_det_bt_le_channel;
5009
5010 if (board_info->tfbga_package) /* for TFBGA */
5011 psd_scan->ant_det_thres_offset = 5;
5012 else
5013 psd_scan->ant_det_thres_offset = 0;
5014
5015 do {
5016 switch (state) {
5017 case 0:
5018 if (bt_le_channel == 39)
5019 wlpsd_cent_freq = 2484;
5020 else {
5021 for (i = 1; i <= 13; i++) {
5022 if (bt_le_ch[i - 1] ==
5023 bt_le_channel) {
5024 wlpsd_cent_freq = 2412
5025 + (i - 1) * 5;
5026 break;
5027 }
5028 }
5029
5030 if (i == 14) {
5031
5032 BTC_SPRINTF(trace_buf,
5033 BT_TMP_BUF_SIZE,
5034 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort!!, Invalid LE channel = %d\n ",
5035 bt_le_channel);
5036 BTC_TRACE(trace_buf);
5037 outloop = TRUE;
5038 break;
5039 }
5040 }
5041 #if 0
5042 wlpsd_sweep_count = bt_tx_time * 238 /
5043 100; /* bt_tx_time/0.42 */
5044 wlpsd_sweep_count = wlpsd_sweep_count / 5;
5045
5046 if (wlpsd_sweep_count % 5 != 0)
5047 wlpsd_sweep_count = (wlpsd_sweep_count /
5048 5 + 1) * 5;
5049 #endif
5050 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5051 "xxxxxxxxxxxxxxxx AntennaDetect(), BT_LETxTime=%d, BT_LECh = %d\n",
5052 bt_tx_time, bt_le_channel);
5053 BTC_TRACE(trace_buf);
5054 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5055 "xxxxxxxxxxxxxxxx AntennaDetect(), wlpsd_cent_freq=%d, wlpsd_offset = %d, wlpsd_span = %d, wlpsd_sweep_count = %d\n",
5056 wlpsd_cent_freq,
5057 wlpsd_offset,
5058 wlpsd_span,
5059 BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT);
5060 BTC_TRACE(trace_buf);
5061
5062 state = 1;
5063 break;
5064 case 1: /* stop coex DM & set antenna path */
5065 /* Stop Coex DM */
5066 btcoexist->stop_coex_dm = TRUE;
5067
5068 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5069 "xxxxxxxxxxxxxxxx AntennaDetect(), Stop Coex DM!!\n");
5070 BTC_TRACE(trace_buf);
5071
5072 /* Set TDMA off, */
5073 /* Set coex table */
5074 halbtc8723d2ant_coex_table_with_type(btcoexist,
5075 FORCE_EXEC, 0);
5076
5077 halbtc8723d2ant_ps_tdma(btcoexist, FORCE_EXEC,
5078 FALSE, 0);
5079
5080 if (board_info->btdm_ant_pos ==
5081 BTC_ANTENNA_AT_MAIN_PORT) {
5082 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5083 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Main Port\n");
5084 BTC_TRACE(trace_buf);
5085 } else {
5086 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5087 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Aux Port\n");
5088 BTC_TRACE(trace_buf);
5089 }
5090
5091 /* Set Antenna path, switch WiFi to un-certain antenna port */
5092 /* Set Antenna Path, both GNT_WL/GNT_BT = 1, and control by SW */
5093 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
5094 FORCE_EXEC,
5095 BT_8723D_2ANT_PHASE_ANTENNA_DET);
5096
5097 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5098 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to BT!!\n");
5099 BTC_TRACE(trace_buf);
5100
5101 /* Set AFH mask on at WiFi channel 2472MHz +/- 10MHz */
5102 h2c_parameter[0] = 0x1;
5103 h2c_parameter[1] = 0xd;
5104 h2c_parameter[2] = 0x14;
5105
5106 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5107 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
5108 h2c_parameter[1],
5109 h2c_parameter[2]);
5110 BTC_TRACE(trace_buf);
5111
5112 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
5113 h2c_parameter);
5114
5115 u32tmp = btcoexist->btc_read_2byte(btcoexist, 0x948);
5116 u32tmp0 = btcoexist->btc_read_4byte(btcoexist, 0x70);
5117 u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(
5118 btcoexist, 0x38);
5119 u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(
5120 btcoexist, 0x54);
5121
5122 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5123 "[BTCoex], ********** 0x948 = 0x%x, 0x70 = 0x%x, 0x38= 0x%x, 0x54= 0x%x (Before Ant Det)\n",
5124 u32tmp, u32tmp0, u32tmp1, u32tmp2);
5125 BTC_TRACE(trace_buf);
5126
5127 state = 2;
5128 break;
5129 case 2: /* Pre-sweep background psd */
5130 if (!halbtc8723d2ant_psd_sweep_point(btcoexist,
5131 wlpsd_cent_freq, wlpsd_offset, wlpsd_span,
5132 BT_8723D_2ANT_ANTDET_PSD_POINTS,
5133 BT_8723D_2ANT_ANTDET_PSD_AVGNUM, 3)) {
5134 ant_det_finish = FALSE;
5135 board_info->btdm_ant_num_by_ant_det = 1;
5136 psd_scan->ant_det_result = 8;
5137 state = 99;
5138 break;
5139 }
5140
5141 psd_scan->ant_det_pre_psdscan_peak_val =
5142 psd_scan->psd_max_value;
5143
5144 if (psd_scan->ant_det_pre_psdscan_peak_val >
5145 (BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
5146 + psd_scan->ant_det_thres_offset) * 100) {
5147 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5148 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort Antenna Detection!! becaus background = %d > thres (%d)\n",
5149 psd_scan->ant_det_pre_psdscan_peak_val /
5150 100,
5151 BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
5152 + psd_scan->ant_det_thres_offset);
5153 BTC_TRACE(trace_buf);
5154 ant_det_finish = FALSE;
5155 board_info->btdm_ant_num_by_ant_det = 1;
5156 psd_scan->ant_det_result = 5;
5157 state = 99;
5158 } else {
5159 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5160 "xxxxxxxxxxxxxxxx AntennaDetect(), Start Antenna Detection!! becaus background = %d <= thres (%d)\n",
5161 psd_scan->ant_det_pre_psdscan_peak_val /
5162 100,
5163 BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
5164 + psd_scan->ant_det_thres_offset);
5165 BTC_TRACE(trace_buf);
5166 state = 3;
5167 }
5168 break;
5169 case 3:
5170 bt_resp = btcoexist->btc_set_bt_ant_detection(
5171 btcoexist, (u8)(bt_tx_time & 0xff),
5172 (u8)(bt_le_channel & 0xff));
5173
5174 /* Sync WL Rx PSD with BT Tx time because H2C->Mailbox delay */
5175 delay_ms(20);
5176
5177 if (!halbtc8723d2ant_psd_sweep_point(btcoexist,
5178 wlpsd_cent_freq, wlpsd_offset,
5179 wlpsd_span,
5180 BT_8723D_2ANT_ANTDET_PSD_POINTS,
5181 BT_8723D_2ANT_ANTDET_PSD_AVGNUM,
5182 BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT)) {
5183 ant_det_finish = FALSE;
5184 board_info->btdm_ant_num_by_ant_det = 1;
5185 psd_scan->ant_det_result = 8;
5186 state = 99;
5187 break;
5188 }
5189
5190 #if 1
5191 psd_scan->ant_det_psd_scan_peak_val =
5192 psd_scan->psd_max_value;
5193 #endif
5194 #if 0
5195 psd_scan->ant_det_psd_scan_peak_val =
5196 ((psd_scan->psd_max_value - psd_scan->psd_avg_value) <
5197 800) ?
5198 psd_scan->psd_max_value : ((
5199 psd_scan->psd_max_value -
5200 psd_scan->psd_max_value2 <= 300) ?
5201 psd_scan->psd_avg_value :
5202 psd_scan->psd_max_value2);
5203 #endif
5204 psd_scan->ant_det_psd_scan_peak_freq =
5205 psd_scan->psd_max_value_point;
5206 state = 4;
5207 break;
5208 case 4:
5209
5210 if (psd_scan->psd_point == 0)
5211 delta_freq_per_point = 0;
5212 else
5213 delta_freq_per_point =
5214 psd_scan->psd_band_width /
5215 psd_scan->psd_point;
5216
5217 psd_rep1 = psd_scan->ant_det_psd_scan_peak_val / 100;
5218 psd_rep2 = psd_scan->ant_det_psd_scan_peak_val -
5219 psd_rep1 *
5220 100;
5221
5222 freq = ((psd_scan->real_cent_freq - 20) *
5223 1000000 + psd_scan->psd_max_value_point
5224 * delta_freq_per_point);
5225 freq1 = freq / 1000000;
5226 freq2 = freq / 1000 - freq1 * 1000;
5227
5228 if (freq2 < 100) {
5229 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5230 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.0%d MHz",
5231 freq1, freq2);
5232 BTC_TRACE(trace_buf);
5233 CL_SPRINTF(psd_scan->ant_det_peak_freq,
5234 BT_8723D_2ANT_ANTDET_BUF_LEN,
5235 "%d.0%d", freq1, freq2);
5236 } else {
5237 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5238 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.%d MHz",
5239 freq1, freq2);
5240 BTC_TRACE(trace_buf);
5241 CL_SPRINTF(psd_scan->ant_det_peak_freq,
5242 BT_8723D_2ANT_ANTDET_BUF_LEN,
5243 "%d.%d", freq1, freq2);
5244 }
5245
5246 if (psd_rep2 < 10) {
5247 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5248 ", Value = %d.0%d dB\n",
5249 psd_rep1, psd_rep2);
5250 BTC_TRACE(trace_buf);
5251 CL_SPRINTF(psd_scan->ant_det_peak_val,
5252 BT_8723D_2ANT_ANTDET_BUF_LEN,
5253 "%d.0%d", psd_rep1, psd_rep2);
5254 } else {
5255 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5256 ", Value = %d.%d dB\n",
5257 psd_rep1, psd_rep2);
5258 BTC_TRACE(trace_buf);
5259 CL_SPRINTF(psd_scan->ant_det_peak_val,
5260 BT_8723D_2ANT_ANTDET_BUF_LEN,
5261 "%d.%d", psd_rep1, psd_rep2);
5262 }
5263
5264 psd_scan->ant_det_is_btreply_available = TRUE;
5265
5266 if (bt_resp == FALSE) {
5267 psd_scan->ant_det_is_btreply_available =
5268 FALSE;
5269 psd_scan->ant_det_result = 0;
5270 ant_det_finish = FALSE;
5271 board_info->btdm_ant_num_by_ant_det = 1;
5272 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5273 "xxxxxxxxxxxxxxxx AntennaDetect(), BT Response = Fail\n ");
5274 BTC_TRACE(trace_buf);
5275 } else if (psd_scan->ant_det_psd_scan_peak_val >
5276 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
5277 * 100) {
5278 psd_scan->ant_det_result = 1;
5279 ant_det_finish = TRUE;
5280 board_info->btdm_ant_num_by_ant_det = 2;
5281 coex_sta->isolation_btween_wb = (u8)(85 -
5282 psd_scan->ant_det_psd_scan_peak_val /
5283 100) & 0xff;
5284 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5285 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Bad-Isolation!!\n");
5286 BTC_TRACE(trace_buf);
5287 } else if (psd_scan->ant_det_psd_scan_peak_val >
5288 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
5289 + psd_scan->ant_det_thres_offset) * 100) {
5290 psd_scan->ant_det_result = 2;
5291 ant_det_finish = TRUE;
5292 board_info->btdm_ant_num_by_ant_det = 2;
5293 coex_sta->isolation_btween_wb = (u8)(85 -
5294 psd_scan->ant_det_psd_scan_peak_val /
5295 100) & 0xff;
5296 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5297 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Good-Isolation!!\n");
5298 BTC_TRACE(trace_buf);
5299 } else if (psd_scan->ant_det_psd_scan_peak_val >
5300 (BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT) *
5301 100) {
5302 psd_scan->ant_det_result = 3;
5303 ant_det_finish = TRUE;
5304 board_info->btdm_ant_num_by_ant_det = 1;
5305 coex_sta->isolation_btween_wb = (u8)(85 -
5306 psd_scan->ant_det_psd_scan_peak_val /
5307 100) & 0xff;
5308 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5309 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant!!\n");
5310 BTC_TRACE(trace_buf);
5311 } else {
5312 psd_scan->ant_det_result = 4;
5313 ant_det_finish = FALSE;
5314 board_info->btdm_ant_num_by_ant_det = 1;
5315 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5316 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant, un-certainity!!\n");
5317 BTC_TRACE(trace_buf);
5318 }
5319
5320 state = 99;
5321 break;
5322 case 99: /* restore setup */
5323
5324 /* Set AFH mask off at WiFi channel 2472MHz +/- 10MHz */
5325 h2c_parameter[0] = 0x0;
5326 h2c_parameter[1] = 0x0;
5327 h2c_parameter[2] = 0x0;
5328
5329 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5330 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
5331 h2c_parameter[1], h2c_parameter[2]);
5332 BTC_TRACE(trace_buf);
5333
5334 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
5335 h2c_parameter);
5336
5337 /* Set Antenna Path, GNT_WL/GNT_BT control by PTA */
5338 /* Set Antenna path, switch WiFi to certain antenna port */
5339 halbtc8723d2ant_set_ant_path(btcoexist,
5340 BTC_ANT_PATH_AUTO, FORCE_EXEC,
5341 BT_8723D_2ANT_PHASE_2G_RUNTIME);
5342
5343 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5344 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to PTA\n!!");
5345 BTC_TRACE(trace_buf);
5346
5347 btcoexist->stop_coex_dm = FALSE;
5348
5349 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5350 "xxxxxxxxxxxxxxxx AntennaDetect(), Resume Coex DM\n!!");
5351 BTC_TRACE(trace_buf);
5352
5353 outloop = TRUE;
5354 break;
5355 }
5356
5357 } while (!outloop);
5358
5359 return ant_det_finish;
5360
5361 }
5362
5363 #ifdef PLATFORM_WINDOWS
5364 #pragma optimize("", off)
5365 #endif
halbtc8723d2ant_psd_antenna_detection_check(IN struct btc_coexist * btcoexist)5366 boolean halbtc8723d2ant_psd_antenna_detection_check(IN struct btc_coexist
5367 *btcoexist)
5368 {
5369 static u32 ant_det_count = 0, ant_det_fail_count = 0;
5370 struct btc_board_info *board_info = &btcoexist->board_info;
5371
5372 boolean scan, roam, ant_det_finish = FALSE;
5373
5374 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
5375 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
5376
5377 ant_det_count++;
5378
5379 psd_scan->ant_det_try_count = ant_det_count;
5380
5381 if (scan || roam) {
5382 ant_det_finish = FALSE;
5383 psd_scan->ant_det_result = 6;
5384 } else if (coex_sta->bt_disabled) {
5385 ant_det_finish = FALSE;
5386 psd_scan->ant_det_result = 11;
5387 } else if (coex_sta->num_of_profile >= 1) {
5388 ant_det_finish = FALSE;
5389 psd_scan->ant_det_result = 7;
5390 } else if (
5391 !psd_scan->ant_det_is_ant_det_available) { /* Antenna initial setup is not ready */
5392 ant_det_finish = FALSE;
5393 psd_scan->ant_det_result = 9;
5394 } else if (coex_sta->c2h_bt_inquiry_page) {
5395 ant_det_finish = FALSE;
5396 psd_scan->ant_det_result = 10;
5397 } else {
5398
5399 ant_det_finish = halbtc8723d2ant_psd_antenna_detection(
5400 btcoexist);
5401
5402 delay_ms(psd_scan->ant_det_bt_tx_time);
5403 }
5404
5405
5406 if (!ant_det_finish)
5407 ant_det_fail_count++;
5408
5409 psd_scan->ant_det_fail_count = ant_det_fail_count;
5410
5411 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5412 "xxxxxxxxxxxxxxxx AntennaDetect(), result = %d, fail_count = %d, finish = %s\n",
5413 psd_scan->ant_det_result,
5414 psd_scan->ant_det_fail_count,
5415 ant_det_finish == TRUE ? "Yes" : "No");
5416 BTC_TRACE(trace_buf);
5417
5418 return ant_det_finish;
5419
5420 }
5421
5422
5423 /* ************************************************************
5424 * work around function start with wa_halbtc8723d2ant_
5425 * ************************************************************
5426 * ************************************************************
5427 * extern function start with ex_halbtc8723d2ant_
5428 * ************************************************************ */
ex_halbtc8723d2ant_power_on_setting(IN struct btc_coexist * btcoexist)5429 void ex_halbtc8723d2ant_power_on_setting(IN struct btc_coexist *btcoexist)
5430 {
5431 struct btc_board_info *board_info = &btcoexist->board_info;
5432 u8 u8tmp = 0x0;
5433 u16 u16tmp = 0x0;
5434 u32 value = 0;
5435
5436 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5437 "xxxxxxxxxxxxxxxx Execute 8723d 2-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
5438 BTC_TRACE(trace_buf);
5439
5440 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5441 "Ant Det Finish = %s, Ant Det Number = %d\n",
5442 (board_info->btdm_ant_det_finish ? "Yes" : "No"),
5443 board_info->btdm_ant_num_by_ant_det);
5444 BTC_TRACE(trace_buf);
5445
5446
5447 btcoexist->stop_coex_dm = TRUE;
5448 coex_sta->is_rf_state_off = FALSE;
5449 psd_scan->ant_det_is_ant_det_available = FALSE;
5450
5451 /* enable BB, REG_SYS_FUNC_EN such that we can write BB Register correctly. */
5452 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
5453 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
5454
5455
5456 /* Local setting bit define */
5457 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
5458 /* BIT1: "0" for internal switch; "1" for external switch */
5459 /* BIT2: "0" for one antenna; "1" for two antenna */
5460 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
5461
5462 /* Set path control to WL */
5463 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x80, 0x1);
5464 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
5465
5466 /* Check efuse 0xc3[6] for Single Antenna Path */
5467 if (board_info->single_ant_path == 0) {
5468 /* set to S1 */
5469 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
5470 u8tmp = 4;
5471 value = 1;
5472 } else if (board_info->single_ant_path == 1) {
5473 /* set to S0 */
5474 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
5475 u8tmp = 5;
5476 value = 0;
5477 }
5478
5479 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5480 "[BTCoex], ********** (Power On) single_ant_path = %d, btdm_ant_pos = %d **********\n",
5481 board_info->single_ant_path , board_info->btdm_ant_pos);
5482 BTC_TRACE(trace_buf);
5483
5484 /* Set Antenna Path to BT side */
5485 halbtc8723d2ant_set_ant_path(btcoexist,
5486 BTC_ANT_PATH_AUTO,
5487 FORCE_EXEC,
5488 BT_8723D_1ANT_PHASE_COEX_POWERON);
5489
5490 /* Write Single Antenna Position to Registry to tell BT for 872db. This line can be removed
5491 since BT EFuse also add "single antenna position" in EFuse for 8723d*/
5492 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
5493 &value);
5494
5495 /* Save"single antenna position" info in Local register setting for FW reading, because FW may not ready at power on */
5496 if (btcoexist->chip_interface == BTC_INTF_PCI)
5497 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x3e0, u8tmp);
5498 else if (btcoexist->chip_interface == BTC_INTF_USB)
5499 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
5500 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
5501 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60, u8tmp);
5502
5503 /* enable GNT_WL/GNT_BT debug signal to GPIO14/15 */
5504 halbtc8723d2ant_enable_gnt_to_gpio(btcoexist, TRUE);
5505
5506 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5507 "[BTCoex], ********** LTE coex Reg 0x38 (Power-On) = 0x%x**********\n",
5508 halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38));
5509 BTC_TRACE(trace_buf);
5510
5511 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5512 "[BTCoex], ********** MAC Reg 0x70/ BB Reg 0x948 (Power-On) = 0x%x / 0x%x**********\n",
5513 btcoexist->btc_read_4byte(btcoexist, 0x70),
5514 btcoexist->btc_read_2byte(btcoexist, 0x948));
5515 BTC_TRACE(trace_buf);
5516 }
5517
ex_halbtc8723d2ant_pre_load_firmware(IN struct btc_coexist * btcoexist)5518 void ex_halbtc8723d2ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
5519 {
5520 struct btc_board_info *board_info = &btcoexist->board_info;
5521 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
5522
5523 /* */
5524 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
5525 /* Local setting bit define */
5526 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
5527 /* BIT1: "0" for internal switch; "1" for external switch */
5528 /* BIT2: "0" for one antenna; "1" for two antenna */
5529 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
5530 if (btcoexist->chip_interface == BTC_INTF_USB) {
5531 /* fixed at S0 for USB interface */
5532 u8tmp |= 0x1; /* antenna inverse */
5533 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
5534 } else {
5535 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
5536 if (board_info->single_ant_path == 0) {
5537 } else if (board_info->single_ant_path == 1) {
5538 /* set to S0 */
5539 u8tmp |= 0x1; /* antenna inverse */
5540 }
5541
5542 if (btcoexist->chip_interface == BTC_INTF_PCI)
5543 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x3e0,
5544 u8tmp);
5545 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
5546 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
5547 u8tmp);
5548 }
5549 }
5550
5551
ex_halbtc8723d2ant_init_hw_config(IN struct btc_coexist * btcoexist,IN boolean wifi_only)5552 void ex_halbtc8723d2ant_init_hw_config(IN struct btc_coexist *btcoexist,
5553 IN boolean wifi_only)
5554 {
5555 halbtc8723d2ant_init_hw_config(btcoexist, wifi_only);
5556 }
5557
ex_halbtc8723d2ant_init_coex_dm(IN struct btc_coexist * btcoexist)5558 void ex_halbtc8723d2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
5559 {
5560
5561 halbtc8723d2ant_init_coex_dm(btcoexist);
5562 }
5563
ex_halbtc8723d2ant_display_coex_info(IN struct btc_coexist * btcoexist)5564 void ex_halbtc8723d2ant_display_coex_info(IN struct btc_coexist *btcoexist)
5565 {
5566 struct btc_board_info *board_info = &btcoexist->board_info;
5567 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
5568 u8 *cli_buf = btcoexist->cli_buf;
5569 u8 u8tmp[4], i, ps_tdma_case = 0;
5570 u32 u32tmp[4];
5571 u16 u16tmp[4];
5572 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck, bt_coex_ver = 0;
5573 u32 fw_ver = 0, bt_patch_ver = 0;
5574 static u8 pop_report_in_10s = 0, cnt = 0;
5575 u32 phyver = 0;
5576 boolean lte_coex_on = FALSE;
5577
5578 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5579 "\r\n ============[BT Coexist info]============");
5580 CL_PRINTF(cli_buf);
5581
5582 if (btcoexist->manual_control) {
5583 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5584 "\r\n ============[Under Manual Control]============");
5585 CL_PRINTF(cli_buf);
5586 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5587 "\r\n ==========================================");
5588 CL_PRINTF(cli_buf);
5589 }
5590
5591 if (!coex_sta->bt_disabled) {
5592
5593 if (coex_sta->bt_coex_supported_feature == 0)
5594 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_FEATURE,
5595 &coex_sta->bt_coex_supported_feature);
5596
5597 if ((coex_sta->bt_coex_supported_version == 0) ||
5598 (coex_sta->bt_coex_supported_version == 0xffff))
5599 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_VERSION,
5600 &coex_sta->bt_coex_supported_version);
5601
5602 if (coex_sta->bt_reg_vendor_ac == 0xffff)
5603 coex_sta->bt_reg_vendor_ac = (u16)(
5604 btcoexist->btc_get_bt_reg(btcoexist, 3,
5605 0xac) & 0xffff);
5606
5607 if (coex_sta->bt_reg_vendor_ae == 0xffff)
5608 coex_sta->bt_reg_vendor_ae = (u16)(
5609 btcoexist->btc_get_bt_reg(btcoexist, 3,
5610 0xae) & 0xffff);
5611
5612 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
5613 &bt_patch_ver);
5614 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
5615
5616 if (coex_sta->num_of_profile > 0) {
5617 cnt++;
5618
5619 if (cnt >= 3) {
5620 btcoexist->btc_get_bt_afh_map_from_bt(btcoexist, 0,
5621 &coex_sta->bt_afh_map[0]);
5622 cnt = 0;
5623 }
5624 }
5625 }
5626
5627 if (psd_scan->ant_det_try_count == 0) {
5628 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s",
5629 "Ant PG Num/ Mech/ Pos",
5630 board_info->pg_ant_num, board_info->btdm_ant_num,
5631 (board_info->btdm_ant_pos == 1 ? "S1" : "S0"));
5632 CL_PRINTF(cli_buf);
5633 } else {
5634 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5635 "\r\n %-35s = %d/ %d/ %s (retry=%d/fail=%d/result=%d)",
5636 "Ant PG Num/ Mech(Ant_Det)/ Pos",
5637 board_info->pg_ant_num,
5638 board_info->btdm_ant_num_by_ant_det,
5639 (board_info->btdm_ant_pos == 1 ? "S1" : "S0"),
5640 psd_scan->ant_det_try_count,
5641 psd_scan->ant_det_fail_count,
5642 psd_scan->ant_det_result);
5643 CL_PRINTF(cli_buf);
5644
5645 if (board_info->btdm_ant_det_finish) {
5646
5647 if (psd_scan->ant_det_result != 12)
5648 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5649 "\r\n %-35s = %s",
5650 "Ant Det PSD Value",
5651 psd_scan->ant_det_peak_val);
5652 else
5653 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5654 "\r\n %-35s = %d",
5655 "Ant Det PSD Value",
5656 psd_scan->ant_det_psd_scan_peak_val
5657 / 100);
5658 CL_PRINTF(cli_buf);
5659 }
5660 }
5661
5662 if (board_info->ant_det_result_five_complete) {
5663 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5664 "\r\n %-35s = %d/ %d",
5665 "AntDet(Registry) Num/PSD Value",
5666 board_info->btdm_ant_num_by_ant_det,
5667 (board_info->antdetval & 0x7f));
5668 CL_PRINTF(cli_buf);
5669 }
5670
5671
5672 bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
5673 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
5674 phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
5675
5676 bt_coex_ver = coex_sta->bt_coex_supported_version & 0xff;
5677
5678 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5679 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
5680 "CoexVer WL/ BT_Desired/ BT_Report",
5681 glcoex_ver_date_8723d_2ant, glcoex_ver_8723d_2ant,
5682 glcoex_ver_btdesired_8723d_2ant,
5683 bt_coex_ver,
5684 (bt_coex_ver == 0xff ? "Unknown" :
5685 (coex_sta->bt_disabled ? "BT-disable" :
5686 (bt_coex_ver >= glcoex_ver_btdesired_8723d_2ant ?
5687 "Match" : "Mis-Match"))));
5688 CL_PRINTF(cli_buf);
5689
5690 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5691 "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
5692 "W_FW/ B_FW/ Phy/ Kt",
5693 fw_ver, bt_patch_ver, phyver,
5694 coex_sta->cut_version + 65);
5695 CL_PRINTF(cli_buf);
5696
5697 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
5698 "Wifi channel informed to BT",
5699 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
5700 coex_dm->wifi_chnl_info[2]);
5701 CL_PRINTF(cli_buf);
5702
5703 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d ",
5704 "Isolation/WL_Thres/BT_Thres",
5705 coex_sta->isolation_btween_wb,
5706 coex_sta->wifi_coex_thres,
5707 coex_sta->bt_coex_thres);
5708 CL_PRINTF(cli_buf);
5709
5710 /* wifi status */
5711 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5712 "============[Wifi Status]============");
5713 CL_PRINTF(cli_buf);
5714 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
5715
5716 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5717 "============[BT Status]============");
5718 CL_PRINTF(cli_buf);
5719
5720 pop_report_in_10s++;
5721 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5722 "\r\n %-35s = [%s/ %d dBm/ %d/ %d] ",
5723 "BT [status/ rssi/ retryCnt/ popCnt]",
5724 ((coex_sta->bt_disabled) ? ("disabled") : ((
5725 coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page")
5726 : ((BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
5727 coex_dm->bt_status) ? "non-connected idle" :
5728 ((BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
5729 ? "connected-idle" : "busy")))),
5730 coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
5731 coex_sta->pop_event_cnt);
5732 CL_PRINTF(cli_buf);
5733
5734 if (pop_report_in_10s >= 5) {
5735 coex_sta->pop_event_cnt = 0;
5736 pop_report_in_10s = 0;
5737 }
5738
5739
5740 if (coex_sta->num_of_profile != 0)
5741 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5742 "\r\n %-35s = %s%s%s%s%s",
5743 "Profiles",
5744 ((bt_link_info->a2dp_exist) ?
5745 ((coex_sta->is_bt_a2dp_sink) ? "A2DP sink," :
5746 "A2DP,") : ""),
5747 ((bt_link_info->sco_exist) ? "HFP," : ""),
5748 ((bt_link_info->hid_exist) ?
5749 ((coex_sta->hid_busy_num >= 2) ? "HID(4/18)," :
5750 "HID(2/18),") : ""),
5751 ((bt_link_info->pan_exist) ? "PAN," : ""),
5752 ((coex_sta->voice_over_HOGP) ? "Voice" : ""));
5753 else
5754 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5755 "\r\n %-35s = None", "Profiles");
5756
5757 CL_PRINTF(cli_buf);
5758
5759
5760 if (bt_link_info->a2dp_exist) {
5761 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s",
5762 "A2DP Rate/Bitpool/Auto_Slot",
5763 ((coex_sta->is_A2DP_3M) ? "3M" : "No_3M"),
5764 coex_sta->a2dp_bit_pool,
5765 ((coex_sta->is_autoslot) ? "On" : "Off")
5766 );
5767 CL_PRINTF(cli_buf);
5768 }
5769
5770 if (bt_link_info->hid_exist) {
5771 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5772 "HID PairNum/Forbid_Slot",
5773 coex_sta->hid_pair_cnt,
5774 coex_sta->forbidden_slot
5775 );
5776 CL_PRINTF(cli_buf);
5777 }
5778
5779 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s/ 0x%x",
5780 "Role/RoleSwCnt/IgnWlact/Feature",
5781 ((bt_link_info->slave_role) ? "Slave" : "Master"),
5782 coex_sta->cnt_RoleSwitch,
5783 ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
5784 coex_sta->bt_coex_supported_feature);
5785 CL_PRINTF(cli_buf);
5786
5787 if ((coex_sta->bt_ble_scan_type & 0x7) != 0x0) {
5788 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5789 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5790 "BLEScan Type/TV/Init/Ble",
5791 coex_sta->bt_ble_scan_type,
5792 (coex_sta->bt_ble_scan_type & 0x1 ?
5793 coex_sta->bt_ble_scan_para[0] : 0x0),
5794 (coex_sta->bt_ble_scan_type & 0x2 ?
5795 coex_sta->bt_ble_scan_para[1] : 0x0),
5796 (coex_sta->bt_ble_scan_type & 0x4 ?
5797 coex_sta->bt_ble_scan_para[2] : 0x0));
5798 CL_PRINTF(cli_buf);
5799 }
5800
5801 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
5802 "ReInit/ReLink/IgnWlact/Page/NameReq",
5803 coex_sta->cnt_ReInit,
5804 coex_sta->cnt_setupLink,
5805 coex_sta->cnt_IgnWlanAct,
5806 coex_sta->cnt_Page,
5807 coex_sta->cnt_RemoteNameReq
5808 );
5809 CL_PRINTF(cli_buf);
5810
5811 halbtc8723d2ant_read_score_board(btcoexist, &u16tmp[0]);
5812
5813 if ((coex_sta->bt_reg_vendor_ae == 0xffff) ||
5814 (coex_sta->bt_reg_vendor_ac == 0xffff))
5815 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = x/ x/ %04x",
5816 "0xae[4]/0xac[1:0]/Scoreboard(B->W)", u16tmp[0]);
5817 else
5818 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5819 "\r\n %-35s = 0x%x/ 0x%x/ %04x",
5820 "0xae[4]/0xac[1:0]/Scoreboard(B->W)",
5821 ((coex_sta->bt_reg_vendor_ae & BIT(4)) >> 4),
5822 coex_sta->bt_reg_vendor_ac & 0x3, u16tmp[0]);
5823 CL_PRINTF(cli_buf);
5824
5825 if (coex_sta->num_of_profile > 0) {
5826
5827 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5828 "\r\n %-35s = %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x",
5829 "AFH MAP",
5830 coex_sta->bt_afh_map[0],
5831 coex_sta->bt_afh_map[1],
5832 coex_sta->bt_afh_map[2],
5833 coex_sta->bt_afh_map[3],
5834 coex_sta->bt_afh_map[4],
5835 coex_sta->bt_afh_map[5],
5836 coex_sta->bt_afh_map[6],
5837 coex_sta->bt_afh_map[7],
5838 coex_sta->bt_afh_map[8],
5839 coex_sta->bt_afh_map[9]
5840 );
5841 CL_PRINTF(cli_buf);
5842 }
5843
5844 for (i = 0; i < BT_INFO_SRC_8723D_2ANT_MAX; i++) {
5845 if (coex_sta->bt_info_c2h_cnt[i]) {
5846 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5847 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x (%d)",
5848 glbt_info_src_8723d_2ant[i],
5849 coex_sta->bt_info_c2h[i][0],
5850 coex_sta->bt_info_c2h[i][1],
5851 coex_sta->bt_info_c2h[i][2],
5852 coex_sta->bt_info_c2h[i][3],
5853 coex_sta->bt_info_c2h[i][4],
5854 coex_sta->bt_info_c2h[i][5],
5855 coex_sta->bt_info_c2h[i][6],
5856 coex_sta->bt_info_c2h_cnt[i]);
5857 CL_PRINTF(cli_buf);
5858 }
5859 }
5860
5861 /* Sw mechanism */
5862 if (btcoexist->manual_control)
5863 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5864 "============[mechanism] (before Manual)============");
5865 else
5866 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5867 "============[Mechanism]============");
5868
5869 CL_PRINTF(cli_buf);
5870
5871
5872 ps_tdma_case = coex_dm->cur_ps_tdma;
5873
5874 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5875 "\r\n %-35s = %02x %02x %02x %02x %02x (case-%d, %s, %s)",
5876 "TDMA",
5877 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
5878 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
5879 coex_dm->ps_tdma_para[4], ps_tdma_case,
5880 (coex_dm->cur_ps_tdma_on ? "TDMA On" : "TDMA Off"),
5881 (coex_dm->is_switch_to_1dot5_ant ? "1.5Ant" : "2Ant"));
5882 CL_PRINTF(cli_buf);
5883
5884 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
5885 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
5886 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
5887 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5888 "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
5889 "Table/0x6c0/0x6c4/0x6c8",
5890 coex_sta->coex_table_type, u32tmp[0], u32tmp[1], u32tmp[2]);
5891 CL_PRINTF(cli_buf);
5892
5893 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
5894 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
5895 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5896 "\r\n %-35s = 0x%x/ 0x%x/ %04x",
5897 "0x778/0x6cc/Scoreboard(W->B)",
5898 u8tmp[0], u32tmp[0], coex_sta->score_board_WB);
5899 CL_PRINTF(cli_buf);
5900
5901 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
5902 "AntDiv/ ForceLPS",
5903 ((board_info->ant_div_cfg) ? "On" : "Off"),
5904 ((coex_sta->force_lps_ctrl) ? "On" : "Off"));
5905 CL_PRINTF(cli_buf);
5906
5907 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5908 "WL_DACSwing/ BT_Dec_Pwr", coex_dm->cur_fw_dac_swing_lvl,
5909 coex_dm->cur_bt_dec_pwr_lvl);
5910 CL_PRINTF(cli_buf);
5911
5912 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5913 "BT_Empty/BT_Late",
5914 coex_sta->wl_fw_dbg_info[4],
5915 coex_sta->wl_fw_dbg_info[5]);
5916 CL_PRINTF(cli_buf);
5917
5918 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
5919 lte_coex_on = ((u32tmp[0] & BIT(7)) >> 7) ? TRUE : FALSE;
5920
5921 if (lte_coex_on) {
5922
5923 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5924 0xa0);
5925 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5926 0xa4);
5927
5928 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5929 "LTE Coex Table W_L/B_L",
5930 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff);
5931 CL_PRINTF(cli_buf);
5932
5933 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5934 0xa8);
5935 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5936 0xac);
5937 u32tmp[2] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5938 0xb0);
5939 u32tmp[3] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5940 0xb4);
5941
5942 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5943 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5944 "LTE Break Table W_L/B_L/L_W/L_B",
5945 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff,
5946 u32tmp[2] & 0xffff, u32tmp[3] & 0xffff);
5947 CL_PRINTF(cli_buf);
5948
5949 }
5950
5951 /* Hw setting */
5952 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5953 "============[Hw setting]============");
5954 CL_PRINTF(cli_buf);
5955 /*
5956 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
5957 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
5958 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
5959 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
5960 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
5961 "0x430/0x434/0x42a/0x456",
5962 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
5963 CL_PRINTF(cli_buf);
5964 */
5965 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
5966 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
5967 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x73);
5968
5969 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
5970 "LTE Coex/Path Owner",
5971 ((lte_coex_on) ? "On" : "Off") ,
5972 ((u8tmp[0] & BIT(2)) ? "WL" : "BT"));
5973 CL_PRINTF(cli_buf);
5974
5975 if (lte_coex_on) {
5976 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5977 "\r\n %-35s = %d/ %d/ %d/ %d",
5978 "LTE 3Wire/OPMode/UART/UARTMode",
5979 (int)((u32tmp[0] & BIT(6)) >> 6),
5980 (int)((u32tmp[0] & (BIT(5) | BIT(4))) >> 4),
5981 (int)((u32tmp[0] & BIT(3)) >> 3),
5982 (int)(u32tmp[0] & (BIT(2) | BIT(1) | BIT(0))));
5983 CL_PRINTF(cli_buf);
5984
5985 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5986 "LTE_Busy/UART_Busy",
5987 (int)((u32tmp[1] & BIT(1)) >> 1), (int)(u32tmp[1] & BIT(0)));
5988 CL_PRINTF(cli_buf);
5989 }
5990
5991 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5992 "\r\n %-35s = %s (BB:%s)/ %s (BB:%s)/ %s %d",
5993 "GNT_WL_Ctrl/GNT_BT_Ctrl/Dbg",
5994 ((u32tmp[0] & BIT(12)) ? "SW" : "HW"),
5995 ((u32tmp[0] & BIT(8)) ? "SW" : "HW"),
5996 ((u32tmp[0] & BIT(14)) ? "SW" : "HW"),
5997 ((u32tmp[0] & BIT(10)) ? "SW" : "HW"),
5998 ((u8tmp[0] & BIT(3)) ? "On" : "Off"),
5999 coex_sta->gnt_error_cnt);
6000 CL_PRINTF(cli_buf);
6001
6002 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
6003 "GNT_WL/GNT_BT",
6004 (int)((u32tmp[1] & BIT(2)) >> 2),
6005 (int)((u32tmp[1] & BIT(3)) >> 3));
6006 CL_PRINTF(cli_buf);
6007
6008 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x948);
6009 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
6010
6011 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
6012 "0x948/0x67[7]",
6013 u16tmp[0], (int)((u8tmp[0] & BIT(7)) >> 7));
6014 CL_PRINTF(cli_buf);
6015
6016 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x964);
6017 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x864);
6018 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0xab7);
6019 u8tmp[3] = btcoexist->btc_read_1byte(btcoexist, 0xa01);
6020
6021 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
6022 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
6023 "0x964[1]/0x864[0]/0xab7[5]/0xa01[7]",
6024 (int)((u8tmp[0] & BIT(1)) >> 1), (int)((u8tmp[1] & BIT(0))),
6025 (int)((u8tmp[2] & BIT(3)) >> 3),
6026 (int)((u8tmp[3] & BIT(7)) >> 7));
6027 CL_PRINTF(cli_buf);
6028
6029
6030 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x4c6);
6031 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
6032 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x45e);
6033
6034 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
6035 "0x4c6[4]/0x40[5]/0x45e[3](TxRetry)",
6036 (int)((u8tmp[0] & BIT(4)) >> 4),
6037 (int)((u8tmp[1] & BIT(5)) >> 5),
6038 (int)((u8tmp[2] & BIT(3)) >> 3));
6039 CL_PRINTF(cli_buf);
6040
6041 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
6042 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
6043 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x953);
6044 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ %s",
6045 "0x550/0x522/4-RxAGC",
6046 u32tmp[0], u8tmp[0], (u8tmp[1] & 0x2) ? "On" : "Off");
6047 CL_PRINTF(cli_buf);
6048
6049 fa_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_OFDM);
6050 fa_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_CCK);
6051 cca_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_OFDM);
6052 cca_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_CCK);
6053
6054 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
6055 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
6056 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA",
6057 cca_cck, fa_cck, cca_ofdm, fa_ofdm);
6058 CL_PRINTF(cli_buf);
6059
6060 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d (Rx_rate Data/RTS= %d/%d)",
6061 "CRC_OK CCK/11g/11n/11ac",
6062 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
6063 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht,
6064 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate);
6065 CL_PRINTF(cli_buf);
6066
6067 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
6068 "CRC_Err CCK/11g/11n/11n-agg",
6069 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
6070 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
6071 CL_PRINTF(cli_buf);
6072
6073 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d",
6074 "WlHiPri/ Locking/ Locked/ Noisy",
6075 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
6076 (coex_sta->cck_lock ? "Yes" : "No"),
6077 (coex_sta->cck_lock_ever ? "Yes" : "No"),
6078 coex_sta->wl_noisy_level);
6079 CL_PRINTF(cli_buf);
6080
6081 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
6082 "0x770(Hi-pri rx/tx)",
6083 coex_sta->high_priority_rx, coex_sta->high_priority_tx,
6084 (coex_sta->is_hiPri_rx_overhead ? "(scan overhead!!)" : ""));
6085 CL_PRINTF(cli_buf);
6086
6087 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
6088 "0x774(Lo-pri rx/tx)",
6089 coex_sta->low_priority_rx, coex_sta->low_priority_tx,
6090 (bt_link_info->slave_role ? "(Slave!!)" : (
6091 coex_sta->is_tdma_btautoslot_hang ? "(auto-slot hang!!)" : "")));
6092 CL_PRINTF(cli_buf);
6093
6094 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
6095 }
6096
6097
ex_halbtc8723d2ant_ips_notify(IN struct btc_coexist * btcoexist,IN u8 type)6098 void ex_halbtc8723d2ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
6099 {
6100 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
6101 return;
6102
6103 if (BTC_IPS_ENTER == type) {
6104 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6105 "[BTCoex], IPS ENTER notify\n");
6106 BTC_TRACE(trace_buf);
6107 coex_sta->under_ips = TRUE;
6108 coex_sta->under_lps = FALSE;
6109
6110 halbtc8723d2ant_post_state_to_bt(btcoexist,
6111 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6112 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6113 BT_8723D_2ANT_SCOREBOARD_SCAN |
6114 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6115 FALSE);
6116
6117 halbtc8723d2ant_set_ant_path(btcoexist,
6118 BTC_ANT_PATH_AUTO,
6119 FORCE_EXEC,
6120 BT_8723D_2ANT_PHASE_WLAN_OFF);
6121
6122 halbtc8723d2ant_action_coex_all_off(btcoexist);
6123 } else if (BTC_IPS_LEAVE == type) {
6124 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6125 "[BTCoex], IPS LEAVE notify\n");
6126 BTC_TRACE(trace_buf);
6127 coex_sta->under_ips = FALSE;
6128 #if 0
6129 halbtc8723d2ant_post_state_to_bt(btcoexist,
6130 BT_8723D_2ANT_SCOREBOARD_ACTIVE, TRUE);
6131
6132 halbtc8723d2ant_post_state_to_bt(btcoexist,
6133 BT_8723D_2ANT_SCOREBOARD_ONOFF, TRUE);
6134 #endif
6135 halbtc8723d2ant_init_hw_config(btcoexist, FALSE);
6136 halbtc8723d2ant_init_coex_dm(btcoexist);
6137 halbtc8723d2ant_query_bt_info(btcoexist);
6138 }
6139 }
6140
ex_halbtc8723d2ant_lps_notify(IN struct btc_coexist * btcoexist,IN u8 type)6141 void ex_halbtc8723d2ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
6142 {
6143 static boolean pre_force_lps_on = FALSE;
6144
6145 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
6146 return;
6147
6148 if (BTC_LPS_ENABLE == type) {
6149 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6150 "[BTCoex], LPS ENABLE notify\n");
6151 BTC_TRACE(trace_buf);
6152 coex_sta->under_lps = TRUE;
6153 coex_sta->under_ips = FALSE;
6154
6155 if (coex_sta->force_lps_ctrl == TRUE) { /* LPS No-32K */
6156 /* Write WL "Active" in Score-board for PS-TDMA */
6157 pre_force_lps_on = TRUE;
6158 halbtc8723d2ant_post_state_to_bt(btcoexist,
6159 BT_8723D_2ANT_SCOREBOARD_ACTIVE, TRUE);
6160
6161 } else { /* LPS-32K, need check if this h2c 0x71 can work?? (2015/08/28) */
6162 /* Write WL "Non-Active" in Score-board for Native-PS */
6163 pre_force_lps_on = FALSE;
6164 halbtc8723d2ant_post_state_to_bt(btcoexist,
6165 BT_8723D_2ANT_SCOREBOARD_ACTIVE, FALSE);
6166
6167 halbtc8723d2ant_action_wifi_native_lps(btcoexist);
6168 }
6169
6170 } else if (BTC_LPS_DISABLE == type) {
6171 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6172 "[BTCoex], LPS DISABLE notify\n");
6173 BTC_TRACE(trace_buf);
6174 coex_sta->under_lps = FALSE;
6175
6176 halbtc8723d2ant_post_state_to_bt(btcoexist,
6177 BT_8723D_2ANT_SCOREBOARD_ACTIVE, TRUE);
6178
6179 if ((!pre_force_lps_on) && (!coex_sta->force_lps_ctrl))
6180 halbtc8723d2ant_query_bt_info(btcoexist);
6181 }
6182 }
6183
ex_halbtc8723d2ant_scan_notify(IN struct btc_coexist * btcoexist,IN u8 type)6184 void ex_halbtc8723d2ant_scan_notify(IN struct btc_coexist *btcoexist,
6185 IN u8 type)
6186 {
6187 u32 u32tmp;
6188 u8 u8tmpa, u8tmpb;
6189 boolean wifi_connected = FALSE;
6190
6191
6192 if (btcoexist->manual_control ||
6193 btcoexist->stop_coex_dm)
6194 return;
6195
6196 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
6197 &wifi_connected);
6198
6199 /* this can't be removed for RF off_on event, or BT would dis-connect */
6200
6201 if (BTC_SCAN_START == type) {
6202
6203 if (!wifi_connected)
6204 coex_sta->wifi_is_high_pri_task = TRUE;
6205
6206 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6207 "[BTCoex], SCAN START notify\n");
6208 BTC_TRACE(trace_buf);
6209
6210 halbtc8723d2ant_post_state_to_bt(btcoexist,
6211 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6212 BT_8723D_2ANT_SCOREBOARD_SCAN |
6213 BT_8723D_2ANT_SCOREBOARD_ONOFF,
6214 TRUE);
6215
6216 halbtc8723d2ant_query_bt_info(btcoexist);
6217
6218 halbtc8723d2ant_set_ant_path(btcoexist,
6219 BTC_ANT_PATH_AUTO,
6220 FORCE_EXEC,
6221 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6222
6223 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6224
6225 } else if (BTC_SCAN_FINISH == type) {
6226
6227 coex_sta->wifi_is_high_pri_task = FALSE;
6228
6229 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
6230 &coex_sta->scan_ap_num);
6231
6232 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6233 "[BTCoex], SCAN FINISH notify (Scan-AP = %d)\n",
6234 coex_sta->scan_ap_num);
6235 BTC_TRACE(trace_buf);
6236
6237 halbtc8723d2ant_post_state_to_bt(btcoexist,
6238 BT_8723D_2ANT_SCOREBOARD_SCAN, FALSE);
6239
6240 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6241 }
6242
6243 }
6244
ex_halbtc8723d2ant_connect_notify(IN struct btc_coexist * btcoexist,IN u8 type)6245 void ex_halbtc8723d2ant_connect_notify(IN struct btc_coexist *btcoexist,
6246 IN u8 type)
6247 {
6248 if (btcoexist->manual_control ||
6249 btcoexist->stop_coex_dm)
6250 return;
6251
6252 if (BTC_ASSOCIATE_START == type) {
6253
6254 coex_sta->wifi_is_high_pri_task = TRUE;
6255
6256 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6257 "[BTCoex], CONNECT START notify\n");
6258 BTC_TRACE(trace_buf);
6259
6260 halbtc8723d2ant_post_state_to_bt(btcoexist,
6261 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6262 BT_8723D_2ANT_SCOREBOARD_SCAN |
6263 BT_8723D_2ANT_SCOREBOARD_ONOFF,
6264 TRUE);
6265
6266 halbtc8723d2ant_set_ant_path(btcoexist,
6267 BTC_ANT_PATH_AUTO,
6268 FORCE_EXEC,
6269 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6270
6271 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6272 /* To keep TDMA case during connect process,
6273 to avoid changed by Btinfo and runcoexmechanism */
6274 coex_sta->freeze_coexrun_by_btinfo = TRUE;
6275
6276 coex_dm->arp_cnt = 0;
6277
6278 } else if (BTC_ASSOCIATE_FINISH == type) {
6279
6280 coex_sta->wifi_is_high_pri_task = FALSE;
6281 coex_sta->freeze_coexrun_by_btinfo = FALSE;
6282
6283 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6284 "[BTCoex], CONNECT FINISH notify\n");
6285 BTC_TRACE(trace_buf);
6286
6287 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6288 }
6289 }
6290
ex_halbtc8723d2ant_media_status_notify(IN struct btc_coexist * btcoexist,IN u8 type)6291 void ex_halbtc8723d2ant_media_status_notify(IN struct btc_coexist *btcoexist,
6292 IN u8 type)
6293 {
6294 u8 h2c_parameter[3] = {0};
6295 u32 wifi_bw;
6296 u8 wifi_central_chnl;
6297 u8 ap_num = 0;
6298 boolean wifi_under_b_mode = FALSE;
6299
6300 if (btcoexist->manual_control ||
6301 btcoexist->stop_coex_dm)
6302 return;
6303
6304 if (BTC_MEDIA_CONNECT == type) {
6305
6306 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6307 "[BTCoex], MEDIA connect notify\n");
6308 BTC_TRACE(trace_buf);
6309
6310 halbtc8723d2ant_post_state_to_bt(btcoexist,
6311 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6312 BT_8723D_2ANT_SCOREBOARD_ONOFF,
6313 TRUE);
6314
6315 halbtc8723d2ant_set_ant_path(btcoexist,
6316 BTC_ANT_PATH_AUTO,
6317 FORCE_EXEC,
6318 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6319
6320 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
6321 &wifi_under_b_mode);
6322
6323 /* Set CCK Tx/Rx high Pri except 11b mode */
6324 if (wifi_under_b_mode) {
6325 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
6326 0x00); /* CCK Tx */
6327 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
6328 0x00); /* CCK Rx */
6329 } else {
6330
6331 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
6332 0x00); /* CCK Tx */
6333 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
6334 0x10); /* CCK Rx */
6335 }
6336
6337 } else {
6338 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6339 "[BTCoex], MEDIA disconnect notify\n");
6340 BTC_TRACE(trace_buf);
6341
6342 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
6343 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
6344
6345 halbtc8723d2ant_post_state_to_bt(btcoexist,
6346 BT_8723D_2ANT_SCOREBOARD_ACTIVE, FALSE);
6347 }
6348
6349
6350 halbtc8723d2ant_update_wifi_channel_info(btcoexist, type);
6351 }
6352
ex_halbtc8723d2ant_specific_packet_notify(IN struct btc_coexist * btcoexist,IN u8 type)6353 void ex_halbtc8723d2ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
6354 IN u8 type)
6355 {
6356 boolean under_4way = FALSE;
6357
6358 if (btcoexist->manual_control ||
6359 btcoexist->stop_coex_dm)
6360 return;
6361
6362 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
6363 &under_4way);
6364
6365 if (under_4way) {
6366
6367 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6368 "[BTCoex], specific Packet ---- under_4way!!\n");
6369 BTC_TRACE(trace_buf);
6370
6371 coex_sta->wifi_is_high_pri_task = TRUE;
6372 coex_sta->specific_pkt_period_cnt = 2;
6373
6374 } else if (BTC_PACKET_ARP == type) {
6375
6376 coex_dm->arp_cnt++;
6377 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6378 "[BTCoex], specific Packet ARP notify -cnt = %d\n",
6379 coex_dm->arp_cnt);
6380 BTC_TRACE(trace_buf);
6381
6382 } else {
6383
6384 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6385 "[BTCoex], specific Packet DHCP or EAPOL notify [Type = %d]\n",
6386 type);
6387 BTC_TRACE(trace_buf);
6388
6389 coex_sta->wifi_is_high_pri_task = TRUE;
6390 coex_sta->specific_pkt_period_cnt = 2;
6391 }
6392
6393 if (coex_sta->wifi_is_high_pri_task) {
6394 halbtc8723d2ant_post_state_to_bt(btcoexist,
6395 BT_8723D_2ANT_SCOREBOARD_ACTIVE, TRUE);
6396 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6397 }
6398
6399 }
6400
ex_halbtc8723d2ant_bt_info_notify(IN struct btc_coexist * btcoexist,IN u8 * tmp_buf,IN u8 length)6401 void ex_halbtc8723d2ant_bt_info_notify(IN struct btc_coexist *btcoexist,
6402 IN u8 *tmp_buf, IN u8 length)
6403 {
6404 u8 i, rsp_source = 0;
6405 boolean wifi_connected = FALSE;
6406 boolean wifi_scan = FALSE, wifi_link = FALSE, wifi_roam = FALSE,
6407 wifi_busy = FALSE;
6408 static boolean is_scoreboard_scan = FALSE;
6409
6410 if (psd_scan->is_AntDet_running == TRUE) {
6411 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6412 "[BTCoex], bt_info_notify return for AntDet is running\n");
6413 BTC_TRACE(trace_buf);
6414 return;
6415 }
6416
6417 rsp_source = tmp_buf[0] & 0xf;
6418 if (rsp_source >= BT_INFO_SRC_8723D_2ANT_MAX)
6419 rsp_source = BT_INFO_SRC_8723D_2ANT_WIFI_FW;
6420 coex_sta->bt_info_c2h_cnt[rsp_source]++;
6421
6422 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6423 "[BTCoex], Bt_info[%d], len=%d, data=[", rsp_source,
6424 length);
6425 BTC_TRACE(trace_buf);
6426
6427 for (i = 0; i < length; i++) {
6428 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
6429
6430 if (i == length - 1) {
6431 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
6432 tmp_buf[i]);
6433 BTC_TRACE(trace_buf);
6434 } else {
6435 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
6436 tmp_buf[i]);
6437 BTC_TRACE(trace_buf);
6438 }
6439 }
6440
6441 coex_sta->bt_info = coex_sta->bt_info_c2h[rsp_source][1];
6442 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
6443 coex_sta->bt_info_ext2 = coex_sta->bt_info_c2h[rsp_source][5];
6444
6445 if (BT_INFO_SRC_8723D_2ANT_WIFI_FW != rsp_source) {
6446
6447 /* if 0xff, it means BT is under WHCK test */
6448 coex_sta->bt_whck_test = ((coex_sta->bt_info == 0xff) ? TRUE :
6449 FALSE);
6450
6451 coex_sta->bt_create_connection = ((
6452 coex_sta->bt_info_c2h[rsp_source][2] & 0x80) ? TRUE :
6453 FALSE);
6454
6455 /* unit: %, value-100 to translate to unit: dBm */
6456 coex_sta->bt_rssi = coex_sta->bt_info_c2h[rsp_source][3] * 2 +
6457 10;
6458
6459 coex_sta->c2h_bt_remote_name_req = ((
6460 coex_sta->bt_info_c2h[rsp_source][2] & 0x20) ? TRUE :
6461 FALSE);
6462
6463 coex_sta->is_A2DP_3M = ((coex_sta->bt_info_c2h[rsp_source][2] &
6464 0x10) ? TRUE : FALSE);
6465
6466 coex_sta->acl_busy = ((coex_sta->bt_info_c2h[rsp_source][1] &
6467 0x8) ? TRUE : FALSE);
6468
6469 coex_sta->voice_over_HOGP = ((coex_sta->bt_info_ext & 0x10) ?
6470 TRUE : FALSE);
6471
6472 coex_sta->c2h_bt_inquiry_page = ((coex_sta->bt_info &
6473 BT_INFO_8723D_2ANT_B_INQ_PAGE) ? TRUE : FALSE);
6474
6475 coex_sta->a2dp_bit_pool = (((
6476 coex_sta->bt_info_c2h[rsp_source][1] & 0x49) == 0x49) ?
6477 coex_sta->bt_info_c2h[rsp_source][6] : 0);
6478
6479 coex_sta->is_bt_a2dp_sink = (coex_sta->bt_info_c2h[rsp_source][6] & 0x80) ?
6480 TRUE : FALSE;
6481
6482 coex_sta->bt_retry_cnt = coex_sta->bt_info_c2h[rsp_source][2] &
6483 0xf;
6484
6485 coex_sta->is_autoslot = coex_sta->bt_info_ext2 & 0x8;
6486
6487 coex_sta->forbidden_slot = coex_sta->bt_info_ext2 & 0x7;
6488
6489 coex_sta->hid_busy_num = (coex_sta->bt_info_ext2 & 0x30) >> 4;
6490
6491 coex_sta->hid_pair_cnt = (coex_sta->bt_info_ext2 & 0xc0) >> 6;
6492
6493 if (coex_sta->bt_retry_cnt >= 1)
6494 coex_sta->pop_event_cnt++;
6495
6496 if (coex_sta->c2h_bt_remote_name_req)
6497 coex_sta->cnt_RemoteNameReq++;
6498
6499 if (coex_sta->bt_info_ext & BIT(1))
6500 coex_sta->cnt_ReInit++;
6501
6502 if (coex_sta->bt_info_ext & BIT(2)) {
6503 coex_sta->cnt_setupLink++;
6504 coex_sta->is_setupLink = TRUE;
6505 coex_sta->bt_relink_downcount = 2;
6506 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6507 "[BTCoex], Re-Link start in BT info!!\n");
6508 BTC_TRACE(trace_buf);
6509 } else {
6510 coex_sta->is_setupLink = FALSE;
6511 coex_sta->bt_relink_downcount = 0;
6512 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6513 "[BTCoex], Re-Link stop in BT info!!\n");
6514 BTC_TRACE(trace_buf);
6515 }
6516
6517 if (coex_sta->bt_info_ext & BIT(3))
6518 coex_sta->cnt_IgnWlanAct++;
6519
6520 if (coex_sta->bt_info_ext & BIT(6))
6521 coex_sta->cnt_RoleSwitch++;
6522
6523 if (coex_sta->bt_info_ext & BIT(7))
6524 coex_sta->is_bt_multi_link = TRUE;
6525 else
6526 coex_sta->is_bt_multi_link = FALSE;
6527
6528 if (coex_sta->bt_create_connection) {
6529 coex_sta->cnt_Page++;
6530
6531 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
6532 &wifi_busy);
6533
6534 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
6535 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
6536 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
6537
6538 if ((wifi_link) || (wifi_roam) || (wifi_scan) ||
6539 (coex_sta->wifi_is_high_pri_task) || (wifi_busy)) {
6540
6541 is_scoreboard_scan = TRUE;
6542 halbtc8723d2ant_post_state_to_bt(btcoexist,
6543 BT_8723D_2ANT_SCOREBOARD_SCAN, TRUE);
6544
6545 } else
6546 halbtc8723d2ant_post_state_to_bt(btcoexist,
6547 BT_8723D_2ANT_SCOREBOARD_SCAN, FALSE);
6548
6549 } else {
6550 if (is_scoreboard_scan) {
6551 halbtc8723d2ant_post_state_to_bt(btcoexist,
6552 BT_8723D_2ANT_SCOREBOARD_SCAN, FALSE);
6553 is_scoreboard_scan = FALSE;
6554 }
6555 }
6556
6557 /* Here we need to resend some wifi info to BT */
6558 /* because bt is reset and loss of the info. */
6559
6560 if ((!btcoexist->manual_control) &&
6561 (!btcoexist->stop_coex_dm)) {
6562
6563 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
6564 &wifi_connected);
6565
6566 /* Re-Init */
6567 if ((coex_sta->bt_info_ext & BIT(1))) {
6568 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6569 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
6570 BTC_TRACE(trace_buf);
6571 if (wifi_connected)
6572 halbtc8723d2ant_update_wifi_channel_info(
6573 btcoexist, BTC_MEDIA_CONNECT);
6574 else
6575 halbtc8723d2ant_update_wifi_channel_info(
6576 btcoexist,
6577 BTC_MEDIA_DISCONNECT);
6578 }
6579
6580
6581 /* If Ignore_WLanAct && not SetUp_Link or Role_Switch */
6582 if ((coex_sta->bt_info_ext & BIT(3)) &&
6583 (!(coex_sta->bt_info_ext & BIT(2))) &&
6584 (!(coex_sta->bt_info_ext & BIT(6)))) {
6585
6586 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6587 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
6588 BTC_TRACE(trace_buf);
6589 halbtc8723d2ant_ignore_wlan_act(btcoexist,
6590 FORCE_EXEC, FALSE);
6591 } else {
6592 if (coex_sta->bt_info_ext & BIT(2)) {
6593 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6594 "[BTCoex], BT ignore Wlan active because Re-link!!\n");
6595 BTC_TRACE(trace_buf);
6596 } else if (coex_sta->bt_info_ext & BIT(6)) {
6597 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6598 "[BTCoex], BT ignore Wlan active because Role-Switch!!\n");
6599 BTC_TRACE(trace_buf);
6600 }
6601 }
6602 }
6603
6604 }
6605
6606 if ((coex_sta->bt_info_ext & BIT(5))) {
6607 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6608 "[BTCoex], BT ext info bit4 check, query BLE Scan type!!\n");
6609 BTC_TRACE(trace_buf);
6610 coex_sta->bt_ble_scan_type = btcoexist->btc_get_ble_scan_type_from_bt(btcoexist);
6611
6612 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1)
6613 coex_sta->bt_ble_scan_para[0] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x1);
6614 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2)
6615 coex_sta->bt_ble_scan_para[1] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x2);
6616 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4)
6617 coex_sta->bt_ble_scan_para[2] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x4);
6618 }
6619
6620 halbtc8723d2ant_update_bt_link_info(btcoexist);
6621
6622 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6623 }
6624
ex_halbtc8723d2ant_wl_fwdbginfo_notify(IN struct btc_coexist * btcoexist,IN u8 * tmp_buf,IN u8 length)6625 void ex_halbtc8723d2ant_wl_fwdbginfo_notify(IN struct btc_coexist *btcoexist,
6626 IN u8 *tmp_buf, IN u8 length)
6627 {
6628 u8 i = 0;
6629 static u8 tmp_buf_pre[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
6630
6631 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6632 "[BTCoex], WiFi Fw Dbg info = %d %d %d %d %d %d (len = %d)\n",
6633 tmp_buf[0], tmp_buf[1],
6634 tmp_buf[2], tmp_buf[3],
6635 tmp_buf[4], tmp_buf[5], length);
6636 BTC_TRACE(trace_buf);
6637
6638 if (tmp_buf[0] == 0x8) {
6639 for (i = 1; i <= 5; i++) {
6640 coex_sta->wl_fw_dbg_info[i] =
6641 (tmp_buf[i] >= tmp_buf_pre[i]) ?
6642 (tmp_buf[i] - tmp_buf_pre[i]) :
6643 (255 - tmp_buf_pre[i] + tmp_buf[i]);
6644
6645 tmp_buf_pre[i] = tmp_buf[i];
6646 }
6647 }
6648 }
6649
6650
ex_halbtc8723d2ant_rx_rate_change_notify(IN struct btc_coexist * btcoexist,IN BOOLEAN is_data_frame,IN u8 btc_rate_id)6651 void ex_halbtc8723d2ant_rx_rate_change_notify(IN struct btc_coexist *btcoexist,
6652 IN BOOLEAN is_data_frame, IN u8 btc_rate_id)
6653 {
6654 BOOLEAN wifi_connected = FALSE;
6655
6656 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
6657 &wifi_connected);
6658
6659 if (is_data_frame) {
6660 coex_sta->wl_rx_rate = btc_rate_id;
6661
6662 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6663 "[BTCoex], rx_rate_change_notify data rate id = %d, RTS_Rate = %d\n",
6664 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate);
6665 BTC_TRACE(trace_buf);
6666 } else {
6667 coex_sta->wl_rts_rx_rate = btc_rate_id;
6668
6669 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6670 "[BTCoex], rts_rate_change_notify RTS rate id = %d, RTS_Rate = %d\n",
6671 coex_sta->wl_rts_rx_rate, coex_sta->wl_rts_rx_rate);
6672 BTC_TRACE(trace_buf);
6673 }
6674
6675 if ((wifi_connected) &&
6676 ((coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_ACL_BUSY) ||
6677 (coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY) ||
6678 (coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_SCO_BUSY))) {
6679
6680 if ((coex_sta->wl_rx_rate == BTC_CCK_5_5) ||
6681 (coex_sta->wl_rx_rate == BTC_OFDM_6) ||
6682 (coex_sta->wl_rx_rate == BTC_MCS_0)) {
6683
6684 coex_sta->cck_lock_warn = TRUE;
6685
6686 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6687 "[BTCoex], cck lock warning...\n");
6688 BTC_TRACE(trace_buf);
6689 } else if ((coex_sta->wl_rx_rate == BTC_CCK_1) ||
6690 (coex_sta->wl_rx_rate == BTC_CCK_2) ||
6691 (coex_sta->wl_rts_rx_rate == BTC_CCK_1) ||
6692 (coex_sta->wl_rts_rx_rate == BTC_CCK_2)) {
6693
6694 coex_sta->cck_lock = TRUE;
6695 coex_sta->cck_lock_ever = TRUE;
6696
6697 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6698 "[BTCoex], cck locking...\n");
6699 BTC_TRACE(trace_buf);
6700 } else {
6701 coex_sta->cck_lock_warn = FALSE;
6702 coex_sta->cck_lock = FALSE;
6703
6704 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6705 "[BTCoex], cck unlock...\n");
6706 BTC_TRACE(trace_buf);
6707 }
6708 } else {
6709 if ((coex_dm->bt_status ==
6710 BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE) ||
6711 (coex_dm->bt_status ==
6712 BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE)) {
6713 coex_sta->cck_lock_warn = FALSE;
6714 coex_sta->cck_lock = FALSE;
6715 }
6716 }
6717
6718 }
6719
6720
6721
ex_halbtc8723d2ant_rf_status_notify(IN struct btc_coexist * btcoexist,IN u8 type)6722 void ex_halbtc8723d2ant_rf_status_notify(IN struct btc_coexist *btcoexist,
6723 IN u8 type)
6724 {
6725 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
6726 BTC_TRACE(trace_buf);
6727
6728 if (BTC_RF_ON == type) {
6729 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6730 "[BTCoex], RF is turned ON!!\n");
6731 BTC_TRACE(trace_buf);
6732
6733 btcoexist->stop_coex_dm = FALSE;
6734 coex_sta->is_rf_state_off = FALSE;
6735 #if 0
6736 halbtc8723d2ant_post_state_to_bt(btcoexist,
6737 BT_8723D_2ANT_SCOREBOARD_ACTIVE, TRUE);
6738 halbtc8723d2ant_post_state_to_bt(btcoexist,
6739 BT_8723D_2ANT_SCOREBOARD_ONOFF, TRUE);
6740 #endif
6741 } else if (BTC_RF_OFF == type) {
6742 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6743 "[BTCoex], RF is turned OFF!!\n");
6744 BTC_TRACE(trace_buf);
6745
6746 halbtc8723d2ant_set_ant_path(btcoexist,
6747 BTC_ANT_PATH_AUTO,
6748 FORCE_EXEC,
6749 BT_8723D_2ANT_PHASE_WLAN_OFF);
6750
6751 halbtc8723d2ant_action_coex_all_off(btcoexist);
6752
6753 halbtc8723d2ant_post_state_to_bt(btcoexist,
6754 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6755 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6756 BT_8723D_2ANT_SCOREBOARD_SCAN |
6757 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6758 FALSE);
6759
6760 btcoexist->stop_coex_dm = TRUE;
6761 coex_sta->is_rf_state_off = FALSE;
6762 }
6763 }
6764
ex_halbtc8723d2ant_halt_notify(IN struct btc_coexist * btcoexist)6765 void ex_halbtc8723d2ant_halt_notify(IN struct btc_coexist *btcoexist)
6766 {
6767 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
6768 BTC_TRACE(trace_buf);
6769
6770 halbtc8723d2ant_set_ant_path(btcoexist,
6771 BTC_ANT_PATH_AUTO,
6772 FORCE_EXEC,
6773 BT_8723D_2ANT_PHASE_WLAN_OFF);
6774
6775 ex_halbtc8723d2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
6776
6777 halbtc8723d2ant_post_state_to_bt(btcoexist,
6778 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6779 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6780 BT_8723D_2ANT_SCOREBOARD_SCAN |
6781 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6782 FALSE);
6783 }
6784
ex_halbtc8723d2ant_pnp_notify(IN struct btc_coexist * btcoexist,IN u8 pnp_state)6785 void ex_halbtc8723d2ant_pnp_notify(IN struct btc_coexist *btcoexist,
6786 IN u8 pnp_state)
6787 {
6788 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Pnp notify\n");
6789 BTC_TRACE(trace_buf);
6790
6791 if ((BTC_WIFI_PNP_SLEEP == pnp_state) ||
6792 (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state)) {
6793 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6794 "[BTCoex], Pnp notify to SLEEP\n");
6795 BTC_TRACE(trace_buf);
6796
6797 /* Sinda 20150819, workaround for driver skip leave IPS/LPS to speed up sleep time. */
6798 /* Driver do not leave IPS/LPS when driver is going to sleep, so BTCoexistence think wifi is still under IPS/LPS */
6799 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch state after wakeup. */
6800 coex_sta->under_ips = FALSE;
6801 coex_sta->under_lps = FALSE;
6802
6803 halbtc8723d2ant_post_state_to_bt(btcoexist,
6804 BT_8723D_2ANT_SCOREBOARD_ACTIVE |
6805 BT_8723D_2ANT_SCOREBOARD_ONOFF |
6806 BT_8723D_2ANT_SCOREBOARD_SCAN |
6807 BT_8723D_2ANT_SCOREBOARD_UNDERTEST,
6808 FALSE);
6809
6810 if (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state) {
6811
6812 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6813 FORCE_EXEC,
6814 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6815 } else {
6816
6817 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6818 FORCE_EXEC,
6819 BT_8723D_2ANT_PHASE_WLAN_OFF);
6820 }
6821
6822
6823 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
6824 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6825 "[BTCoex], Pnp notify to WAKE UP\n");
6826 BTC_TRACE(trace_buf);
6827 #if 0
6828 halbtc8723d2ant_post_state_to_bt(btcoexist,
6829 BT_8723D_2ANT_SCOREBOARD_ACTIVE, TRUE);
6830 halbtc8723d2ant_post_state_to_bt(btcoexist,
6831 BT_8723D_2ANT_SCOREBOARD_ONOFF, TRUE);
6832 #endif
6833 }
6834 }
6835
ex_halbtc8723d2ant_periodical(IN struct btc_coexist * btcoexist)6836 void ex_halbtc8723d2ant_periodical(IN struct btc_coexist *btcoexist)
6837 {
6838 struct btc_board_info *board_info = &btcoexist->board_info;
6839 boolean wifi_busy = FALSE;
6840 u32 bt_patch_ver;
6841 static u8 cnt = 0;
6842 boolean bt_relink_finish = FALSE;
6843
6844 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6845 "[BTCoex], ************* Periodical *************\n");
6846 BTC_TRACE(trace_buf);
6847
6848 #if (BT_AUTO_REPORT_ONLY_8723D_2ANT == 0)
6849 halbtc8723d2ant_query_bt_info(btcoexist);
6850 #endif
6851
6852 halbtc8723d2ant_monitor_bt_ctr(btcoexist);
6853 halbtc8723d2ant_monitor_wifi_ctr(btcoexist);
6854 halbtc8723d2ant_monitor_bt_enable_disable(btcoexist);
6855
6856 #if 0
6857 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
6858
6859 /* halbtc8723d2ant_read_score_board(btcoexist, &bt_scoreboard_val); */
6860
6861 if (wifi_busy) {
6862 halbtc8723d2ant_post_state_to_bt(btcoexist,
6863 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, TRUE);
6864 /*
6865 halbtc8723d2ant_post_state_to_bt(btcoexist,
6866 BT_8723D_2ANT_SCOREBOARD_WLBUSY, TRUE);
6867
6868 if (bt_scoreboard_val & BIT(6))
6869 halbtc8723d2ant_query_bt_info(btcoexist); */
6870 } else {
6871 halbtc8723d2ant_post_state_to_bt(btcoexist,
6872 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, FALSE);
6873 /*
6874 halbtc8723d2ant_post_state_to_bt(btcoexist,
6875 BT_8723D_2ANT_SCOREBOARD_WLBUSY,
6876 FALSE); */
6877 }
6878 #endif
6879
6880 if (coex_sta->bt_relink_downcount != 0) {
6881 coex_sta->bt_relink_downcount--;
6882
6883 if (coex_sta->bt_relink_downcount == 0) {
6884 coex_sta->is_setupLink = FALSE;
6885 bt_relink_finish = TRUE;
6886 }
6887 }
6888
6889 /* for 4-way, DHCP, EAPOL packet */
6890 if (coex_sta->specific_pkt_period_cnt > 0) {
6891
6892 coex_sta->specific_pkt_period_cnt--;
6893
6894 if ((coex_sta->specific_pkt_period_cnt == 0) &&
6895 (coex_sta->wifi_is_high_pri_task))
6896 coex_sta->wifi_is_high_pri_task = FALSE;
6897
6898 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6899 "[BTCoex], ***************** Hi-Pri Task = %s*****************\n",
6900 (coex_sta->wifi_is_high_pri_task ? "Yes" :
6901 "No"));
6902 BTC_TRACE(trace_buf);
6903
6904 }
6905
6906 if (!coex_sta->bt_disabled) {
6907
6908 #if BT_8723D_2ANT_ANTDET_ENABLE
6909
6910 if (board_info->btdm_ant_det_finish) {
6911 if ((psd_scan->ant_det_result == 12) &&
6912 (psd_scan->ant_det_psd_scan_peak_val == 0)
6913 && (!psd_scan->is_AntDet_running))
6914 psd_scan->ant_det_psd_scan_peak_val =
6915 btcoexist->btc_get_ant_det_val_from_bt(
6916 btcoexist) * 100;
6917 }
6918
6919 #endif
6920 }
6921
6922
6923 if (halbtc8723d2ant_is_wifibt_status_changed(btcoexist) || (bt_relink_finish))
6924 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6925 }
6926
ex_halbtc8723d2ant_set_antenna_notify(IN struct btc_coexist * btcoexist,IN u8 type)6927 void ex_halbtc8723d2ant_set_antenna_notify(IN struct btc_coexist *btcoexist,
6928 IN u8 type)
6929 {
6930 struct btc_board_info *board_info = &btcoexist->board_info;
6931
6932 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
6933 return;
6934
6935 if (type == 2) { /* two antenna */
6936 board_info->ant_div_cfg = TRUE;
6937
6938 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
6939 FORCE_EXEC,
6940 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6941
6942 } else { /* one antenna */
6943
6944 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6945 FORCE_EXEC,
6946 BT_8723D_2ANT_PHASE_2G_RUNTIME);
6947
6948 }
6949 }
6950
6951 #ifdef PLATFORM_WINDOWS
6952 #pragma optimize("", off)
6953 #endif
ex_halbtc8723d2ant_antenna_detection(IN struct btc_coexist * btcoexist,IN u32 cent_freq,IN u32 offset,IN u32 span,IN u32 seconds)6954 void ex_halbtc8723d2ant_antenna_detection(IN struct btc_coexist *btcoexist,
6955 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
6956 {
6957
6958 static u32 ant_det_count = 0, ant_det_fail_count = 0;
6959 struct btc_board_info *board_info = &btcoexist->board_info;
6960 u16 u16tmp;
6961 u8 AntDetval = 0;
6962
6963 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6964 "xxxxxxxxxxxxxxxx Ext Call AntennaDetect()!!\n");
6965 BTC_TRACE(trace_buf);
6966
6967 #if BT_8723D_2ANT_ANTDET_ENABLE
6968
6969 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6970 "xxxxxxxxxxxxxxxx Call AntennaDetect()!!\n");
6971 BTC_TRACE(trace_buf);
6972
6973 if (seconds == 0) {
6974 psd_scan->ant_det_try_count = 0;
6975 psd_scan->ant_det_fail_count = 0;
6976 ant_det_count = 0;
6977 ant_det_fail_count = 0;
6978 board_info->btdm_ant_det_finish = FALSE;
6979 board_info->btdm_ant_num_by_ant_det = 1;
6980 return;
6981 }
6982
6983 if (!board_info->btdm_ant_det_finish) {
6984 psd_scan->ant_det_inteval_count =
6985 psd_scan->ant_det_inteval_count + 2;
6986
6987 if (psd_scan->ant_det_inteval_count >=
6988 BT_8723D_2ANT_ANTDET_RETRY_INTERVAL) {
6989 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6990 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is up, Try Detect!!\n");
6991 BTC_TRACE(trace_buf);
6992
6993 psd_scan->is_AntDet_running = TRUE;
6994
6995 halbtc8723d2ant_read_score_board(btcoexist, &u16tmp);
6996
6997 if (u16tmp & BIT(
6998 2)) { /* Antenna detection is already done before last WL power on */
6999 board_info->btdm_ant_det_finish = TRUE;
7000 psd_scan->ant_det_try_count = 1;
7001 psd_scan->ant_det_fail_count = 0;
7002 board_info->btdm_ant_num_by_ant_det = (u16tmp &
7003 BIT(3)) ? 1 : 2;
7004 psd_scan->ant_det_result = 12;
7005
7006 psd_scan->ant_det_psd_scan_peak_val =
7007 btcoexist->btc_get_ant_det_val_from_bt(
7008 btcoexist) * 100;
7009
7010 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
7011 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Result from BT (%d-Ant)\n",
7012 board_info->btdm_ant_num_by_ant_det);
7013 BTC_TRACE(trace_buf);
7014 } else
7015 board_info->btdm_ant_det_finish =
7016 halbtc8723d2ant_psd_antenna_detection_check(
7017 btcoexist);
7018
7019 btcoexist->bdontenterLPS = FALSE;
7020
7021 if (board_info->btdm_ant_det_finish) {
7022 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
7023 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Success!!\n");
7024 BTC_TRACE(trace_buf);
7025
7026 /*for 8723d, btc_set_bt_trx_mask is just used to
7027 notify BT stop le tx and Ant Det Result , not set BT RF TRx Mask */
7028 if (psd_scan->ant_det_result != 12) {
7029
7030 AntDetval = (u8)(
7031 psd_scan->ant_det_psd_scan_peak_val
7032 / 100) & 0x7f;
7033
7034 AntDetval =
7035 (board_info->btdm_ant_num_by_ant_det
7036 == 1) ? (AntDetval | 0x80) :
7037 AntDetval;
7038
7039 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
7040 "xxxxxx AntennaDetect(), Ant Count = %d, PSD Val = %d\n",
7041 ((AntDetval &
7042 0x80) ? 1
7043 : 2), AntDetval
7044 & 0x7f);
7045 BTC_TRACE(trace_buf);
7046
7047 if (btcoexist->btc_set_bt_trx_mask(
7048 btcoexist, AntDetval))
7049 BTC_SPRINTF(trace_buf,
7050 BT_TMP_BUF_SIZE,
7051 "xxxxxx AntennaDetect(), Notify BT stop le tx by set_bt_trx_mask ok!\n");
7052 else
7053 BTC_SPRINTF(trace_buf,
7054 BT_TMP_BUF_SIZE,
7055 "xxxxxx AntennaDetect(), Notify BT stop le tx by set_bt_trx_mask fail!\n");
7056
7057 BTC_TRACE(trace_buf);
7058 } else
7059 board_info->antdetval =
7060 psd_scan->ant_det_psd_scan_peak_val/100;
7061
7062 board_info->btdm_ant_det_complete_fail = FALSE;
7063
7064 } else {
7065 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
7066 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Fail!!\n");
7067 BTC_TRACE(trace_buf);
7068 }
7069
7070 psd_scan->ant_det_inteval_count = 0;
7071 psd_scan->is_AntDet_running = FALSE;
7072
7073 /* stimulate coex running */
7074 halbtc8723d2ant_run_coexist_mechanism(
7075 btcoexist);
7076 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
7077 "xxxxxxxxxxxxxxxx AntennaDetect(), Stimulate Coex running\n!!");
7078 BTC_TRACE(trace_buf);
7079 } else {
7080 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
7081 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is not up! (%d)\n",
7082 psd_scan->ant_det_inteval_count);
7083 BTC_TRACE(trace_buf);
7084
7085 if (psd_scan->ant_det_inteval_count == 8)
7086 btcoexist->bdontenterLPS = TRUE;
7087 else
7088 btcoexist->bdontenterLPS = FALSE;
7089 }
7090
7091 }
7092 #endif
7093
7094
7095 }
7096
7097
ex_halbtc8723d2ant_display_ant_detection(IN struct btc_coexist * btcoexist)7098 void ex_halbtc8723d2ant_display_ant_detection(IN struct btc_coexist *btcoexist)
7099 {
7100
7101 #if BT_8723D_2ANT_ANTDET_ENABLE
7102 struct btc_board_info *board_info = &btcoexist->board_info;
7103
7104 if (psd_scan->ant_det_try_count != 0) {
7105 halbtc8723d2ant_psd_show_antenna_detect_result(btcoexist);
7106
7107 if (board_info->btdm_ant_det_finish)
7108 halbtc8723d2ant_psd_showdata(btcoexist);
7109 }
7110 #endif
7111
7112 }
7113
7114
7115 #endif
7116
7117 #endif /* #if (RTL8723D_SUPPORT == 1) */
7118
7119