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