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