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