1 /******************************************************************************
2 *
3 * Copyright(c) 2016 - 2017 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15
16 /* ************************************************************
17 * Description:
18 *
19 * This file is for RTL8703B Co-exist mechanism
20 *
21 * History
22 * 2012/11/15 Cosa first check in.
23 *
24 * ************************************************************ */
25
26 /* ************************************************************
27 * include files
28 * ************************************************************ */
29 #include "mp_precomp.h"
30
31 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
32
33 #if (RTL8703B_SUPPORT == 1)
34 /* ************************************************************
35 * Global variables, these are static variables
36 * ************************************************************ */
37 static u8 *trace_buf = &gl_btc_trace_buf[0];
38 static struct coex_dm_8703b_1ant glcoex_dm_8703b_1ant;
39 static struct coex_dm_8703b_1ant *coex_dm = &glcoex_dm_8703b_1ant;
40 static struct coex_sta_8703b_1ant glcoex_sta_8703b_1ant;
41 static struct coex_sta_8703b_1ant *coex_sta = &glcoex_sta_8703b_1ant;
42 static struct psdscan_sta_8703b_1ant gl_psd_scan_8703b_1ant;
43 static struct psdscan_sta_8703b_1ant *psd_scan = &gl_psd_scan_8703b_1ant;
44
45
46 const char *const glbt_info_src_8703b_1ant[] = {
47 "BT Info[wifi fw]",
48 "BT Info[bt rsp]",
49 "BT Info[bt auto report]",
50 };
51 /* ************************************************************
52 * BtCoex Version Format:
53 * 1. date : glcoex_ver_date_XXXXX_1ant
54 * 2. WifiCoexVersion : glcoex_ver_XXXX_1ant
55 * 3. BtCoexVersion : glcoex_ver_btdesired_XXXXX_1ant
56 * 4. others : glcoex_ver_XXXXXX_XXXXX_1ant
57 *
58 * Variable should be indicated IC and Antenna numbers !!!
59 * Please strictly follow this order and naming style !!!
60 *
61 * ************************************************************ */
62 u32 glcoex_ver_date_8703b_1ant = 20180330;
63 u32 glcoex_ver_8703b_1ant = 0x1e;
64 u32 glcoex_ver_btdesired_8703b_1ant = 0x1c;
65
66
67 /* ************************************************************
68 * local function proto type if needed
69 * ************************************************************
70 * ************************************************************
71 * local function start with halbtc8703b1ant_
72 * ************************************************************ */
halbtc8703b1ant_bt_rssi_state(u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)73 u8 halbtc8703b1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh, u8 rssi_thresh1)
74 {
75 s32 bt_rssi = 0;
76 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
77
78 bt_rssi = coex_sta->bt_rssi;
79
80 if (level_num == 2) {
81 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
82 (coex_sta->pre_bt_rssi_state ==
83 BTC_RSSI_STATE_STAY_LOW)) {
84 if (bt_rssi >= (rssi_thresh +
85 BTC_RSSI_COEX_THRESH_TOL_8703B_1ANT))
86 bt_rssi_state = BTC_RSSI_STATE_HIGH;
87 else
88 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
89 } else {
90 if (bt_rssi < rssi_thresh)
91 bt_rssi_state = BTC_RSSI_STATE_LOW;
92 else
93 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
94 }
95 } else if (level_num == 3) {
96 if (rssi_thresh > rssi_thresh1) {
97 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
98 "[BTCoex], BT Rssi thresh error!!\n");
99 BTC_TRACE(trace_buf);
100 return coex_sta->pre_bt_rssi_state;
101 }
102
103 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
104 (coex_sta->pre_bt_rssi_state ==
105 BTC_RSSI_STATE_STAY_LOW)) {
106 if (bt_rssi >= (rssi_thresh +
107 BTC_RSSI_COEX_THRESH_TOL_8703B_1ANT))
108 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
109 else
110 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
111 } else if ((coex_sta->pre_bt_rssi_state ==
112 BTC_RSSI_STATE_MEDIUM) ||
113 (coex_sta->pre_bt_rssi_state ==
114 BTC_RSSI_STATE_STAY_MEDIUM)) {
115 if (bt_rssi >= (rssi_thresh1 +
116 BTC_RSSI_COEX_THRESH_TOL_8703B_1ANT))
117 bt_rssi_state = BTC_RSSI_STATE_HIGH;
118 else if (bt_rssi < rssi_thresh)
119 bt_rssi_state = BTC_RSSI_STATE_LOW;
120 else
121 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
122 } else {
123 if (bt_rssi < rssi_thresh1)
124 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
125 else
126 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
127 }
128 }
129
130 coex_sta->pre_bt_rssi_state = bt_rssi_state;
131
132 return bt_rssi_state;
133 }
134
halbtc8703b1ant_wifi_rssi_state(IN struct btc_coexist * btcoexist,IN u8 index,IN u8 level_num,IN u8 rssi_thresh,IN u8 rssi_thresh1)135 u8 halbtc8703b1ant_wifi_rssi_state(IN struct btc_coexist *btcoexist,
136 IN u8 index, IN u8 level_num, IN u8 rssi_thresh, IN u8 rssi_thresh1)
137 {
138 s32 wifi_rssi = 0;
139 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
140
141 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
142
143 if (level_num == 2) {
144 if ((coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_LOW)
145 ||
146 (coex_sta->pre_wifi_rssi_state[index] ==
147 BTC_RSSI_STATE_STAY_LOW)) {
148 if (wifi_rssi >= (rssi_thresh +
149 BTC_RSSI_COEX_THRESH_TOL_8703B_1ANT))
150 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
151 else
152 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
153 } else {
154 if (wifi_rssi < rssi_thresh)
155 wifi_rssi_state = BTC_RSSI_STATE_LOW;
156 else
157 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
158 }
159 } else if (level_num == 3) {
160 if (rssi_thresh > rssi_thresh1) {
161 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
162 "[BTCoex], wifi RSSI thresh error!!\n");
163 BTC_TRACE(trace_buf);
164 return coex_sta->pre_wifi_rssi_state[index];
165 }
166
167 if ((coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_LOW)
168 ||
169 (coex_sta->pre_wifi_rssi_state[index] ==
170 BTC_RSSI_STATE_STAY_LOW)) {
171 if (wifi_rssi >= (rssi_thresh +
172 BTC_RSSI_COEX_THRESH_TOL_8703B_1ANT))
173 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
174 else
175 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
176 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
177 BTC_RSSI_STATE_MEDIUM) ||
178 (coex_sta->pre_wifi_rssi_state[index] ==
179 BTC_RSSI_STATE_STAY_MEDIUM)) {
180 if (wifi_rssi >= (rssi_thresh1 +
181 BTC_RSSI_COEX_THRESH_TOL_8703B_1ANT))
182 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
183 else if (wifi_rssi < rssi_thresh)
184 wifi_rssi_state = BTC_RSSI_STATE_LOW;
185 else
186 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
187 } else {
188 if (wifi_rssi < rssi_thresh1)
189 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
190 else
191 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
192 }
193 }
194
195 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
196
197 return wifi_rssi_state;
198 }
199
halbtc8703b1ant_update_ra_mask(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u32 dis_rate_mask)200 void halbtc8703b1ant_update_ra_mask(IN struct btc_coexist *btcoexist,
201 IN boolean force_exec, IN u32 dis_rate_mask)
202 {
203 coex_dm->cur_ra_mask = dis_rate_mask;
204
205 if (force_exec || (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask))
206 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
207 &coex_dm->cur_ra_mask);
208 coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
209 }
210
halbtc8703b1ant_auto_rate_fallback_retry(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)211 void halbtc8703b1ant_auto_rate_fallback_retry(IN struct btc_coexist *btcoexist,
212 IN boolean force_exec, IN u8 type)
213 {
214 boolean wifi_under_b_mode = FALSE;
215
216 coex_dm->cur_arfr_type = type;
217
218 if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
219 switch (coex_dm->cur_arfr_type) {
220 case 0: /* normal mode */
221 btcoexist->btc_write_4byte(btcoexist, 0x430,
222 coex_dm->backup_arfr_cnt1);
223 btcoexist->btc_write_4byte(btcoexist, 0x434,
224 coex_dm->backup_arfr_cnt2);
225 break;
226 case 1:
227 btcoexist->btc_get(btcoexist,
228 BTC_GET_BL_WIFI_UNDER_B_MODE,
229 &wifi_under_b_mode);
230 if (wifi_under_b_mode) {
231 btcoexist->btc_write_4byte(btcoexist,
232 0x430, 0x0);
233 btcoexist->btc_write_4byte(btcoexist,
234 0x434, 0x01010101);
235 } else {
236 btcoexist->btc_write_4byte(btcoexist,
237 0x430, 0x0);
238 btcoexist->btc_write_4byte(btcoexist,
239 0x434, 0x04030201);
240 }
241 break;
242 default:
243 break;
244 }
245 }
246
247 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
248 }
249
halbtc8703b1ant_retry_limit(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)250 void halbtc8703b1ant_retry_limit(IN struct btc_coexist *btcoexist,
251 IN boolean force_exec, IN u8 type)
252 {
253 coex_dm->cur_retry_limit_type = type;
254
255 if (force_exec ||
256 (coex_dm->pre_retry_limit_type !=
257 coex_dm->cur_retry_limit_type)) {
258 switch (coex_dm->cur_retry_limit_type) {
259 case 0: /* normal mode */
260 btcoexist->btc_write_2byte(btcoexist, 0x42a,
261 coex_dm->backup_retry_limit);
262 break;
263 case 1: /* retry limit=8 */
264 btcoexist->btc_write_2byte(btcoexist, 0x42a,
265 0x0808);
266 break;
267 default:
268 break;
269 }
270 }
271
272 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
273 }
274
halbtc8703b1ant_ampdu_max_time(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)275 void halbtc8703b1ant_ampdu_max_time(IN struct btc_coexist *btcoexist,
276 IN boolean force_exec, IN u8 type)
277 {
278 coex_dm->cur_ampdu_time_type = type;
279
280 if (force_exec ||
281 (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
282 switch (coex_dm->cur_ampdu_time_type) {
283 case 0: /* normal mode */
284 btcoexist->btc_write_1byte(btcoexist, 0x456,
285 coex_dm->backup_ampdu_max_time);
286 break;
287 case 1: /* AMPDU timw = 0x38 * 32us */
288 btcoexist->btc_write_1byte(btcoexist, 0x456,
289 0x38);
290 break;
291 default:
292 break;
293 }
294 }
295
296 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
297 }
298
halbtc8703b1ant_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)299 void halbtc8703b1ant_limited_tx(IN struct btc_coexist *btcoexist,
300 IN boolean force_exec, IN u8 ra_mask_type, IN u8 arfr_type,
301 IN u8 retry_limit_type, IN u8 ampdu_time_type)
302 {
303 switch (ra_mask_type) {
304 case 0: /* normal mode */
305 halbtc8703b1ant_update_ra_mask(btcoexist, force_exec,
306 0x0);
307 break;
308 case 1: /* disable cck 1/2 */
309 halbtc8703b1ant_update_ra_mask(btcoexist, force_exec,
310 0x00000003);
311 break;
312 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
313 halbtc8703b1ant_update_ra_mask(btcoexist, force_exec,
314 0x0001f1f7);
315 break;
316 default:
317 break;
318 }
319
320 halbtc8703b1ant_auto_rate_fallback_retry(btcoexist, force_exec,
321 arfr_type);
322 halbtc8703b1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
323 halbtc8703b1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
324 }
325
halbtc8703b1ant_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)326 void halbtc8703b1ant_limited_rx(IN struct btc_coexist *btcoexist,
327 IN boolean force_exec, IN boolean rej_ap_agg_pkt,
328 IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
329 {
330 boolean reject_rx_agg = rej_ap_agg_pkt;
331 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
332 u8 rx_agg_size = agg_buf_size;
333
334 /* ============================================ */
335 /* Rx Aggregation related setting */
336 /* ============================================ */
337 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
338 &reject_rx_agg);
339 /* decide BT control aggregation buf size or not */
340 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
341 &bt_ctrl_rx_agg_size);
342 /* aggregation buf size, only work when BT control Rx aggregation size. */
343 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
344 /* real update aggregation setting */
345 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
346
347
348 }
349
halbtc8703b1ant_query_bt_info(IN struct btc_coexist * btcoexist)350 void halbtc8703b1ant_query_bt_info(IN struct btc_coexist *btcoexist)
351 {
352 u8 h2c_parameter[1] = {0};
353
354
355 h2c_parameter[0] |= BIT(0); /* trigger */
356
357 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
358 }
359
halbtc8703b1ant_monitor_bt_ctr(IN struct btc_coexist * btcoexist)360 void halbtc8703b1ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
361 {
362 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
363 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
364 static u8 num_of_bt_counter_chk = 0, cnt_slave = 0, cnt_overhead = 0,
365 cnt_autoslot_hang = 0;
366 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
367
368 /* to avoid 0x76e[3] = 1 (WLAN_Act control by PTA) during IPS */
369 /* if (! (btcoexist->btc_read_1byte(btcoexist, 0x76e) & 0x8) ) */
370
371 reg_hp_txrx = 0x770;
372 reg_lp_txrx = 0x774;
373
374 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
375 reg_hp_tx = u32tmp & MASKLWORD;
376 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
377
378 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
379 reg_lp_tx = u32tmp & MASKLWORD;
380 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
381
382 coex_sta->high_priority_tx = reg_hp_tx;
383 coex_sta->high_priority_rx = reg_hp_rx;
384 coex_sta->low_priority_tx = reg_lp_tx;
385 coex_sta->low_priority_rx = reg_lp_rx;
386
387 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
388 "[BTCoex], Hi-Pri Rx/Tx: %d/%d, Lo-Pri Rx/Tx: %d/%d\n",
389 reg_hp_rx, reg_hp_tx, reg_lp_rx, reg_lp_tx);
390
391 BTC_TRACE(trace_buf);
392
393 if (BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
394 coex_dm->bt_status) {
395
396 if (coex_sta->high_priority_rx >= 15) {
397 if (cnt_overhead < 3)
398 cnt_overhead++;
399
400 if (cnt_overhead == 3)
401 coex_sta->is_hiPri_rx_overhead = TRUE;
402 } else {
403 if (cnt_overhead > 0)
404 cnt_overhead--;
405
406 if (cnt_overhead == 0)
407 coex_sta->is_hiPri_rx_overhead = FALSE;
408 }
409 } else
410 coex_sta->is_hiPri_rx_overhead = FALSE;
411
412 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
413 "[BTCoex], Hi-Pri Rx/Tx: %d/%d, Lo-Pri Rx/Tx: %d/%d\n",
414 reg_hp_rx, reg_hp_tx, reg_lp_rx, reg_lp_tx);
415
416 BTC_TRACE(trace_buf);
417
418 /* reset counter */
419 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
420
421 if ((coex_sta->low_priority_tx > 1150) &&
422 (!coex_sta->c2h_bt_inquiry_page))
423 coex_sta->pop_event_cnt++;
424
425 if ((coex_sta->low_priority_rx >= 1150) &&
426 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx)
427 && (!coex_sta->under_ips) && (!coex_sta->c2h_bt_inquiry_page) &&
428 (coex_sta->bt_link_exist)) {
429 if (cnt_slave >= 3) {
430 bt_link_info->slave_role = TRUE;
431 cnt_slave = 3;
432 } else
433 cnt_slave++;
434 } else {
435 if (cnt_slave == 0) {
436 bt_link_info->slave_role = FALSE;
437 cnt_slave = 0;
438 } else
439 cnt_slave--;
440
441 }
442
443 if (coex_sta->is_tdma_btautoslot) {
444 if ((coex_sta->low_priority_tx >= 1300) &&
445 (coex_sta->low_priority_rx <= 150)) {
446 if (cnt_autoslot_hang >= 2) {
447 coex_sta->is_tdma_btautoslot_hang = TRUE;
448 cnt_autoslot_hang = 2;
449 } else
450 cnt_autoslot_hang++;
451 } else {
452 if (cnt_autoslot_hang == 0) {
453 coex_sta->is_tdma_btautoslot_hang = FALSE;
454 cnt_autoslot_hang = 0;
455 } else
456 cnt_autoslot_hang--;
457 }
458 }
459
460 if (bt_link_info->hid_only) {
461 if (coex_sta->low_priority_rx > 50)
462 coex_sta->is_hid_low_pri_tx_overhead = true;
463 else
464 coex_sta->is_hid_low_pri_tx_overhead = false;
465 }
466
467 if (!coex_sta->bt_disabled) {
468 if ((coex_sta->high_priority_tx == 0) &&
469 (coex_sta->high_priority_rx == 0) &&
470 (coex_sta->low_priority_tx == 0) &&
471 (coex_sta->low_priority_rx == 0)) {
472 num_of_bt_counter_chk++;
473 if (num_of_bt_counter_chk >= 3) {
474 halbtc8703b1ant_query_bt_info(btcoexist);
475 num_of_bt_counter_chk = 0;
476 }
477 }
478 }
479
480 }
481
482
halbtc8703b1ant_monitor_wifi_ctr(IN struct btc_coexist * btcoexist)483 void halbtc8703b1ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
484 {
485 s32 wifi_rssi = 0;
486 boolean wifi_busy = FALSE, wifi_under_b_mode = FALSE,
487 wifi_scan = FALSE, wifi_connected = FALSE;
488 boolean bt_idle = FALSE, wl_idle = FALSE, is_cck_deadlock = FALSE;
489 static u8 cck_lock_counter = 0, wl_noisy_count0 = 0,
490 wl_noisy_count1 = 3, wl_noisy_count2 = 0;
491 u32 total_cnt, reg_val1, reg_val2, cnt_cck;
492 u32 cnt_crcok = 0, cnt_crcerr = 0;
493 static u8 cnt = 0, cnt_ccklocking = 0;
494 u8 h2c_parameter[1] = {0};
495 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
496
497 /*send h2c to query WL FW dbg info */
498 if (((coex_dm->cur_ps_tdma_on) && (coex_sta->force_lps_ctrl)) ||
499 ((coex_sta->acl_busy) && (bt_link_info->a2dp_exist))) {
500 h2c_parameter[0] = 0x8;
501 btcoexist->btc_fill_h2c(btcoexist, 0x69, 1, h2c_parameter);
502 }
503
504 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
505 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
506 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
507 &wifi_under_b_mode);
508
509 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
510
511 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_PHY_counter(
512 btcoexist,
513 PHYDM_INFO_CRC32_OK_CCK);
514 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_PHY_counter(
515 btcoexist,
516 PHYDM_INFO_CRC32_OK_LEGACY);
517 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_PHY_counter(
518 btcoexist,
519 PHYDM_INFO_CRC32_OK_HT);
520 coex_sta->crc_ok_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
521 btcoexist,
522 PHYDM_INFO_CRC32_OK_VHT);
523
524 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_PHY_counter(
525 btcoexist, PHYDM_INFO_CRC32_ERROR_CCK);
526 coex_sta->crc_err_11g = btcoexist->btc_phydm_query_PHY_counter(
527 btcoexist, PHYDM_INFO_CRC32_ERROR_LEGACY);
528 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_PHY_counter(
529 btcoexist, PHYDM_INFO_CRC32_ERROR_HT);
530 coex_sta->crc_err_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
531 btcoexist,
532 PHYDM_INFO_CRC32_ERROR_VHT);
533
534 cnt_crcok = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g
535 + coex_sta->crc_ok_11n
536 + coex_sta->crc_ok_11n_vht;
537
538 cnt_crcerr = coex_sta->crc_err_cck + coex_sta->crc_err_11g
539 + coex_sta->crc_err_11n
540 + coex_sta->crc_err_11n_vht;
541
542 /* CCK lock identification */
543 if (coex_sta->cck_lock)
544 cnt_ccklocking++;
545 else if (cnt_ccklocking != 0)
546 cnt_ccklocking--;
547
548 if (cnt_ccklocking >= 3) {
549 cnt_ccklocking = 3;
550 coex_sta->cck_lock_ever = TRUE;
551 }
552
553 /* WiFi environment noisy identification */
554 cnt_cck = coex_sta->crc_ok_cck + coex_sta->crc_err_cck;
555
556 if ((!wifi_busy) && (!coex_sta->cck_lock)) {
557 if (cnt_cck > 250) {
558 if (wl_noisy_count2 < 3)
559 wl_noisy_count2++;
560
561 if (wl_noisy_count2 == 3) {
562 wl_noisy_count0 = 0;
563 wl_noisy_count1 = 0;
564 }
565
566 } else if (cnt_cck < 50) {
567 if (wl_noisy_count0 < 3)
568 wl_noisy_count0++;
569
570 if (wl_noisy_count0 == 3) {
571 wl_noisy_count1 = 0;
572 wl_noisy_count2 = 0;
573 }
574
575 } else {
576 if (wl_noisy_count1 < 3)
577 wl_noisy_count1++;
578
579 if (wl_noisy_count1 == 3) {
580 wl_noisy_count0 = 0;
581 wl_noisy_count2 = 0;
582 }
583 }
584
585 if (wl_noisy_count2 == 3)
586 coex_sta->wl_noisy_level = 2;
587 else if (wl_noisy_count1 == 3)
588 coex_sta->wl_noisy_level = 1;
589 else
590 coex_sta->wl_noisy_level = 0;
591 }
592
593 }
594
595
596
597
halbtc8703b1ant_update_bt_link_info(IN struct btc_coexist * btcoexist)598 void halbtc8703b1ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
599 {
600 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
601 boolean bt_hs_on = FALSE;
602 boolean bt_busy = FALSE;
603 u32 val = 0;
604 static u8 pre_num_of_profile = 0, cur_num_of_profile = 0, cnt = 0;
605
606 if (coex_sta->is_ble_scan_toggle) {
607 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
608 "[BTCoex], BT ext info bit4 check, query BLE Scan type!!\n");
609 BTC_TRACE(trace_buf);
610 coex_sta->bt_ble_scan_type = btcoexist->btc_get_ble_scan_type_from_bt(btcoexist);
611
612 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1)
613 coex_sta->bt_ble_scan_para[0] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x1);
614 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2)
615 coex_sta->bt_ble_scan_para[1] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x2);
616 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4)
617 coex_sta->bt_ble_scan_para[2] = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x4);
618 }
619
620 coex_sta->num_of_profile = 0;
621
622 /* set link exist status */
623 if (!(coex_sta->bt_info & BT_INFO_8703B_1ANT_B_CONNECTION)) {
624 coex_sta->bt_link_exist = FALSE;
625 coex_sta->pan_exist = FALSE;
626 coex_sta->a2dp_exist = FALSE;
627 coex_sta->hid_exist = FALSE;
628 coex_sta->sco_exist = FALSE;
629 } else { /* connection exists */
630 coex_sta->bt_link_exist = TRUE;
631 if (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_FTP) {
632 coex_sta->pan_exist = TRUE;
633 coex_sta->num_of_profile++;
634 } else
635 coex_sta->pan_exist = FALSE;
636
637 if (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_A2DP) {
638 coex_sta->a2dp_exist = TRUE;
639 coex_sta->num_of_profile++;
640 } else
641 coex_sta->a2dp_exist = FALSE;
642
643 if (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_HID) {
644 coex_sta->hid_exist = TRUE;
645 coex_sta->num_of_profile++;
646 } else
647 coex_sta->hid_exist = FALSE;
648
649 if (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_SCO_ESCO) {
650 coex_sta->sco_exist = TRUE;
651 coex_sta->num_of_profile++;
652 } else
653 coex_sta->sco_exist = FALSE;
654
655 }
656
657 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
658
659 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
660 bt_link_info->sco_exist = coex_sta->sco_exist;
661 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
662 bt_link_info->pan_exist = coex_sta->pan_exist;
663 bt_link_info->hid_exist = coex_sta->hid_exist;
664 bt_link_info->acl_busy = coex_sta->acl_busy;
665
666 /* work around for HS mode. */
667 if (bt_hs_on) {
668 bt_link_info->pan_exist = TRUE;
669 bt_link_info->bt_link_exist = TRUE;
670 }
671
672 /* check if Sco only */
673 if (bt_link_info->sco_exist &&
674 !bt_link_info->a2dp_exist &&
675 !bt_link_info->pan_exist &&
676 !bt_link_info->hid_exist)
677 bt_link_info->sco_only = TRUE;
678 else
679 bt_link_info->sco_only = FALSE;
680
681 /* check if A2dp only */
682 if (!bt_link_info->sco_exist &&
683 bt_link_info->a2dp_exist &&
684 !bt_link_info->pan_exist &&
685 !bt_link_info->hid_exist)
686 bt_link_info->a2dp_only = TRUE;
687 else
688 bt_link_info->a2dp_only = FALSE;
689
690 /* check if Pan only */
691 if (!bt_link_info->sco_exist &&
692 !bt_link_info->a2dp_exist &&
693 bt_link_info->pan_exist &&
694 !bt_link_info->hid_exist)
695 bt_link_info->pan_only = TRUE;
696 else
697 bt_link_info->pan_only = FALSE;
698
699 /* check if Hid only */
700 if (!bt_link_info->sco_exist &&
701 !bt_link_info->a2dp_exist &&
702 !bt_link_info->pan_exist &&
703 bt_link_info->hid_exist)
704 bt_link_info->hid_only = TRUE;
705 else
706 bt_link_info->hid_only = FALSE;
707
708 if (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_INQ_PAGE) {
709 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_INQ_PAGE;
710 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
711 "[BTCoex], BtInfoNotify(), BT Inq/page!!!\n");
712 } else if (!(coex_sta->bt_info & BT_INFO_8703B_1ANT_B_CONNECTION)) {
713 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
714 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
715 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
716 } else if (coex_sta->bt_info == BT_INFO_8703B_1ANT_B_CONNECTION) {
717 /* connection exists but no busy */
718 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE;
719 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
720 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
721 } else if (((coex_sta->bt_info & BT_INFO_8703B_1ANT_B_SCO_ESCO) ||
722 (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_SCO_BUSY)) &&
723 (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_ACL_BUSY)) {
724 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_ACL_SCO_BUSY;
725 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
726 "[BTCoex], BtInfoNotify(), BT ACL SCO busy!!!\n");
727 } else if ((coex_sta->bt_info & BT_INFO_8703B_1ANT_B_SCO_ESCO) ||
728 (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_SCO_BUSY)) {
729 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_SCO_BUSY;
730 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
731 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
732 } else if (coex_sta->bt_info & BT_INFO_8703B_1ANT_B_ACL_BUSY) {
733 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_ACL_BUSY;
734 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
735 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
736 } else {
737 coex_dm->bt_status = BT_8703B_1ANT_BT_STATUS_MAX;
738 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
739 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
740 }
741
742 BTC_TRACE(trace_buf);
743
744 if ((BT_8703B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
745 (BT_8703B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
746 (BT_8703B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
747 bt_busy = TRUE;
748 else
749 bt_busy = FALSE;
750
751 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
752
753 cur_num_of_profile = coex_sta->num_of_profile;
754
755 if (cur_num_of_profile != pre_num_of_profile)
756 cnt = 2;
757
758 if (bt_link_info->a2dp_exist) {
759
760 if (((coex_sta->bt_a2dp_vendor_id == 0) &&
761 (coex_sta->bt_a2dp_device_name == 0)) ||
762 (cur_num_of_profile != pre_num_of_profile)) {
763
764 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_DEVICE_INFO, &val);
765
766 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
767 "[BTCoex], BtInfoNotify(), get BT DEVICE_INFO = %x\n", val);
768 BTC_TRACE(trace_buf);
769
770 coex_sta->bt_a2dp_vendor_id = (u8)(val & 0xff);
771 coex_sta->bt_a2dp_device_name = (val & 0xffffff00) >> 8;
772 }
773
774 if (((coex_sta->legacy_forbidden_slot == 0) &&
775 (coex_sta->le_forbidden_slot == 0)) ||
776 (cur_num_of_profile != pre_num_of_profile) ||
777 (cnt > 0)) {
778
779 if (cnt > 0)
780 cnt--;
781
782 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_FORBIDDEN_SLOT_VAL, &val);
783
784 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
785 "[BTCoex], BtInfoNotify(), get BT FORBIDDEN_SLOT_VAL = %x\n", val);
786 BTC_TRACE(trace_buf);
787
788 coex_sta->legacy_forbidden_slot = (u16)(val & 0xffff);
789 coex_sta->le_forbidden_slot = (u16)((val & 0xffff0000) >> 16);
790 }
791 }
792
793 pre_num_of_profile = coex_sta->num_of_profile;
794
795 }
796
797
halbtc8703b1ant_update_wifi_channel_info(IN struct btc_coexist * btcoexist,IN u8 type)798 void halbtc8703b1ant_update_wifi_channel_info(IN struct btc_coexist *btcoexist,
799 IN u8 type)
800 {
801 u8 h2c_parameter[3] = {0};
802 u32 wifi_bw;
803 u8 wifi_central_chnl;
804
805 /* only 2.4G we need to inform bt the chnl mask */
806 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
807 &wifi_central_chnl);
808 if ((BTC_MEDIA_CONNECT == type) &&
809 (wifi_central_chnl <= 14)) {
810 h2c_parameter[0] =
811 0x1; /* enable BT AFH skip WL channel for 8703b because BT Rx LO interference */
812 /* h2c_parameter[0] = 0x0; */
813 h2c_parameter[1] = wifi_central_chnl;
814 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
815 if (BTC_WIFI_BW_HT40 == wifi_bw)
816 h2c_parameter[2] = 0x30;
817 else
818 h2c_parameter[2] = 0x20;
819 }
820
821 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
822 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
823 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
824
825 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
826
827 }
828
halbtc8703b1ant_set_bt_auto_report(IN struct btc_coexist * btcoexist,IN boolean enable_auto_report)829 void halbtc8703b1ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
830 IN boolean enable_auto_report)
831 {
832 u8 h2c_parameter[1] = {0};
833
834 h2c_parameter[0] = 0;
835
836 if (enable_auto_report)
837 h2c_parameter[0] |= BIT(0);
838
839 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
840 }
841
halbtc8703b1ant_bt_auto_report(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean enable_auto_report)842 void halbtc8703b1ant_bt_auto_report(IN struct btc_coexist *btcoexist,
843 IN boolean force_exec, IN boolean enable_auto_report)
844 {
845 coex_dm->cur_bt_auto_report = enable_auto_report;
846
847 if (!force_exec) {
848 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
849 return;
850 }
851 halbtc8703b1ant_set_bt_auto_report(btcoexist,
852 coex_dm->cur_bt_auto_report);
853
854 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
855 }
856
halbtc8703b1ant_set_fw_low_penalty_ra(IN struct btc_coexist * btcoexist,IN boolean low_penalty_ra)857 void halbtc8703b1ant_set_fw_low_penalty_ra(IN struct btc_coexist
858 *btcoexist, IN boolean low_penalty_ra)
859 {
860 u8 h2c_parameter[6] = {0};
861
862 h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
863
864 if (low_penalty_ra) {
865 h2c_parameter[1] |= BIT(0);
866 h2c_parameter[2] =
867 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
868 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
869 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
870 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
871 }
872
873 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
874 }
875
halbtc8703b1ant_low_penalty_ra(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean low_penalty_ra)876 void halbtc8703b1ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
877 IN boolean force_exec, IN boolean low_penalty_ra)
878 {
879 coex_dm->cur_low_penalty_ra = low_penalty_ra;
880
881 if (!force_exec) {
882 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
883 return;
884 }
885
886 halbtc8703b1ant_set_fw_low_penalty_ra(btcoexist,
887 coex_dm->cur_low_penalty_ra);
888
889 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
890 }
891
halbtc8703b1ant_write_score_board(IN struct btc_coexist * btcoexist,IN u16 bitpos,IN boolean state)892 void halbtc8703b1ant_write_score_board(
893 IN struct btc_coexist *btcoexist,
894 IN u16 bitpos,
895 IN boolean state
896 )
897 {
898
899 static u16 originalval = 0x8002, preval = 0x0;
900
901 if (state)
902 originalval = originalval | bitpos;
903 else
904 originalval = originalval & (~bitpos);
905
906 coex_sta->score_board_WB = originalval;
907
908 if (originalval != preval) {
909
910 preval = originalval;
911 btcoexist->btc_write_2byte(btcoexist, 0xaa, originalval);
912 } else {
913 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
914 "[BTCoex], halbtc8703b1ant_write_score_board: return for nochange\n");
915 BTC_TRACE(trace_buf);
916 }
917 }
918
919
halbtc8703b1ant_read_score_board(IN struct btc_coexist * btcoexist,IN u16 * score_board_val)920 void halbtc8703b1ant_read_score_board(
921 IN struct btc_coexist *btcoexist,
922 IN u16 *score_board_val
923 )
924 {
925
926 *score_board_val = (btcoexist->btc_read_2byte(btcoexist,
927 0xaa)) & 0x7fff;
928 }
929
halbtc8703b1ant_post_state_to_bt(IN struct btc_coexist * btcoexist,IN u16 type,IN boolean state)930 void halbtc8703b1ant_post_state_to_bt(
931 IN struct btc_coexist *btcoexist,
932 IN u16 type,
933 IN boolean state
934 )
935 {
936 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
937 "[BTCoex], halbtc8703b1ant_post_state_to_bt: type = %d, state =%d\n",
938 type, state);
939 BTC_TRACE(trace_buf);
940
941 halbtc8703b1ant_write_score_board(btcoexist, (u16) type, state);
942 }
943
halbtc8703b1ant_is_wifibt_status_changed(IN struct btc_coexist * btcoexist)944 boolean halbtc8703b1ant_is_wifibt_status_changed(IN struct btc_coexist
945 *btcoexist)
946 {
947 static boolean pre_wifi_busy = FALSE, pre_under_4way = FALSE,
948 pre_bt_hs_on = FALSE, pre_bt_off = FALSE,
949 pre_bt_slave = FALSE, pre_hid_low_pri_tx_overhead = FALSE,
950 pre_wifi_under_lps = FALSE, pre_bt_setup_link = FALSE,
951 pre_cck_lock = FALSE, pre_cck_lock_warn = FALSE;
952 static u8 pre_hid_busy_num = 0, pre_wl_noisy_level = 0;
953 boolean wifi_busy = FALSE, under_4way = FALSE, bt_hs_on = FALSE;
954 boolean wifi_connected = FALSE;
955 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
956
957 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
958 &wifi_connected);
959 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
960 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
961 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
962 &under_4way);
963
964 if (coex_sta->bt_disabled != pre_bt_off) {
965 pre_bt_off = coex_sta->bt_disabled;
966
967 if (coex_sta->bt_disabled)
968 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
969 "[BTCoex], BT is disabled !!\n");
970 else
971 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
972 "[BTCoex], BT is enabled !!\n");
973
974 BTC_TRACE(trace_buf);
975
976 coex_sta->bt_coex_supported_feature = 0;
977 coex_sta->bt_coex_supported_version = 0;
978 coex_sta->bt_ble_scan_type = 0;
979 coex_sta->bt_ble_scan_para[0] = 0;
980 coex_sta->bt_ble_scan_para[1] = 0;
981 coex_sta->bt_ble_scan_para[2] = 0;
982 coex_sta->legacy_forbidden_slot = 0;
983 coex_sta->le_forbidden_slot = 0;
984 coex_sta->bt_a2dp_vendor_id = 0;
985 coex_sta->bt_a2dp_device_name = 0;
986
987 return TRUE;
988 }
989
990 if (wifi_connected) {
991 if (wifi_busy != pre_wifi_busy) {
992 pre_wifi_busy = wifi_busy;
993
994 if (wifi_busy)
995 halbtc8703b1ant_post_state_to_bt(btcoexist,
996 BT_8703B_1ANT_SCOREBOARD_UNDERTEST, TRUE);
997 else
998 halbtc8703b1ant_post_state_to_bt(btcoexist,
999 BT_8703B_1ANT_SCOREBOARD_UNDERTEST, FALSE);
1000 return TRUE;
1001 }
1002 if (under_4way != pre_under_4way) {
1003 pre_under_4way = under_4way;
1004 return TRUE;
1005 }
1006 if (bt_hs_on != pre_bt_hs_on) {
1007 pre_bt_hs_on = bt_hs_on;
1008 return TRUE;
1009 }
1010 if (coex_sta->wl_noisy_level != pre_wl_noisy_level) {
1011 pre_wl_noisy_level = coex_sta->wl_noisy_level;
1012 return TRUE;
1013 }
1014 if (coex_sta->under_lps != pre_wifi_under_lps) {
1015 pre_wifi_under_lps = coex_sta->under_lps;
1016 if (coex_sta->under_lps == TRUE)
1017 return TRUE;
1018 }
1019 if (coex_sta->cck_lock != pre_cck_lock) {
1020 pre_cck_lock = coex_sta->cck_lock;
1021 return TRUE;
1022 }
1023 if (coex_sta->cck_lock_warn != pre_cck_lock_warn) {
1024 pre_cck_lock_warn = coex_sta->cck_lock_warn;
1025 return TRUE;
1026 }
1027 }
1028
1029 if (!coex_sta->bt_disabled) {
1030 if (coex_sta->hid_busy_num != pre_hid_busy_num) {
1031 pre_hid_busy_num = coex_sta->hid_busy_num;
1032 return TRUE;
1033 }
1034
1035 if (bt_link_info->slave_role != pre_bt_slave) {
1036 pre_bt_slave = bt_link_info->slave_role;
1037 return TRUE;
1038 }
1039
1040 if (pre_hid_low_pri_tx_overhead != coex_sta->is_hid_low_pri_tx_overhead) {
1041 pre_hid_low_pri_tx_overhead = coex_sta->is_hid_low_pri_tx_overhead;
1042 return TRUE;
1043 }
1044
1045 if (pre_bt_setup_link != coex_sta->is_setupLink) {
1046 pre_bt_setup_link = coex_sta->is_setupLink;
1047 return TRUE;
1048 }
1049 }
1050
1051 return FALSE;
1052 }
1053
1054
halbtc8703b1ant_monitor_bt_enable_disable(IN struct btc_coexist * btcoexist)1055 void halbtc8703b1ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
1056 {
1057 static u32 bt_disable_cnt = 0;
1058 boolean bt_active = TRUE, bt_disabled = FALSE;
1059 u16 u16tmp;
1060
1061 /* This function check if bt is disabled */
1062 #if 1
1063 if (coex_sta->high_priority_tx == 0 &&
1064 coex_sta->high_priority_rx == 0 &&
1065 coex_sta->low_priority_tx == 0 &&
1066 coex_sta->low_priority_rx == 0)
1067 bt_active = FALSE;
1068 if (coex_sta->high_priority_tx == 0xffff &&
1069 coex_sta->high_priority_rx == 0xffff &&
1070 coex_sta->low_priority_tx == 0xffff &&
1071 coex_sta->low_priority_rx == 0xffff)
1072 bt_active = FALSE;
1073
1074
1075 #else /* 8703b BT can't show correct on/off status in scoreboard[1] 2015/11/26 */
1076
1077 halbtc8703b1ant_read_score_board(btcoexist, &u16tmp);
1078
1079 bt_active = u16tmp & BIT(1);
1080
1081
1082 #endif
1083
1084 if (bt_active) {
1085 bt_disable_cnt = 0;
1086 bt_disabled = FALSE;
1087 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1088 &bt_disabled);
1089 } else {
1090
1091 bt_disable_cnt++;
1092 if (bt_disable_cnt >= 10) {
1093 bt_disabled = TRUE;
1094 bt_disable_cnt = 10;
1095 }
1096
1097 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
1098 &bt_disabled);
1099 }
1100
1101 if (bt_disabled)
1102 halbtc8703b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, FALSE);
1103 else
1104 halbtc8703b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, TRUE);
1105
1106 if (coex_sta->bt_disabled != bt_disabled) {
1107 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1108 "[BTCoex], BT is from %s to %s!!\n",
1109 (coex_sta->bt_disabled ? "disabled" : "enabled"),
1110 (bt_disabled ? "disabled" : "enabled"));
1111 BTC_TRACE(trace_buf);
1112 coex_sta->bt_disabled = bt_disabled;
1113
1114 }
1115 }
1116
1117
1118
halbtc8703b1ant_enable_gnt_to_gpio(IN struct btc_coexist * btcoexist,IN boolean isenable)1119 void halbtc8703b1ant_enable_gnt_to_gpio(IN struct btc_coexist *btcoexist,
1120 IN boolean isenable)
1121 {
1122
1123 #if (BT_8703B_1ANT_ENABLE_GNTBT_TO_GPIO14 == 1)
1124 if (isenable) {
1125 /* enable GNT_WL/GNT_BT debug signal to GPIO14/15 */
1126 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x1);
1127
1128 /* enable GNT_BT debug to GPIO */
1129 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x0);
1130 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x0);
1131 } else {
1132 /* enable GNT_WL/GNT_BT debug signal to GPIO14/15 */
1133 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x0);
1134
1135 /* Disable GNT_BT debug to GPIO, and enable chip_wakeup_host */
1136 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x1);
1137 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x1);
1138 }
1139 #endif
1140 }
1141
halbtc8703b1ant_ltecoex_indirect_read_reg(IN struct btc_coexist * btcoexist,IN u16 reg_addr)1142 u32 halbtc8703b1ant_ltecoex_indirect_read_reg(IN struct btc_coexist *btcoexist,
1143 IN u16 reg_addr)
1144 {
1145 u32 j = 0, delay_count = 0;
1146
1147 /* wait for ready bit before access 0x7c0/0x7c4 */
1148 while (1) {
1149 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3)&BIT(5)) == 0) {
1150 delay_ms(50);
1151 delay_count++;
1152 if (delay_count >= 10) {
1153 delay_count = 0;
1154 break;
1155 }
1156 } else
1157 break;
1158 }
1159
1160 btcoexist->btc_write_4byte(btcoexist, 0x7c0, 0x800F0000 | reg_addr);
1161
1162 return btcoexist->btc_read_4byte(btcoexist,
1163 0x7c8); /* get read data */
1164
1165 }
1166
halbtc8703b1ant_ltecoex_indirect_write_reg(IN struct btc_coexist * btcoexist,IN u16 reg_addr,IN u32 bit_mask,IN u32 reg_value)1167 void halbtc8703b1ant_ltecoex_indirect_write_reg(IN struct btc_coexist
1168 *btcoexist,
1169 IN u16 reg_addr, IN u32 bit_mask, IN u32 reg_value)
1170 {
1171 u32 val, i = 0, j = 0, bitpos = 0, delay_count = 0;
1172
1173 if (bit_mask == 0x0)
1174 return;
1175 if (bit_mask == 0xffffffff) {
1176 /* wait for ready bit before access 0x7c0/0x7c4 */
1177 while (1) {
1178 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3)&BIT(5)) == 0) {
1179 delay_ms(50);
1180 delay_count++;
1181 if (delay_count >= 10) {
1182 delay_count = 0;
1183 break;
1184 }
1185 } else
1186 break;
1187 }
1188
1189 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1190 reg_value); /* put write data */
1191
1192 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1193 0xc00F0000 | reg_addr);
1194 } else {
1195 for (i = 0; i <= 31; i++) {
1196 if (((bit_mask >> i) & 0x1) == 0x1) {
1197 bitpos = i;
1198 break;
1199 }
1200 }
1201
1202 /* read back register value before write */
1203 val = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
1204 reg_addr);
1205 val = (val & (~bit_mask)) | (reg_value << bitpos);
1206
1207 /* wait for ready bit before access 0x7c0/0x7c4 */
1208 while (1) {
1209 if ((btcoexist->btc_read_1byte(btcoexist, 0x7c3)&BIT(5)) == 0) {
1210 delay_ms(50);
1211 delay_count++;
1212 if (delay_count >= 10) {
1213 delay_count = 0;
1214 break;
1215 }
1216 } else
1217 break;
1218 }
1219
1220 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1221 val); /* put write data */
1222
1223 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1224 0xc00F0000 | reg_addr);
1225
1226 }
1227
1228 }
1229
halbtc8703b1ant_ltecoex_enable(IN struct btc_coexist * btcoexist,IN boolean enable)1230 void halbtc8703b1ant_ltecoex_enable(IN struct btc_coexist *btcoexist,
1231 IN boolean enable)
1232 {
1233 u8 val;
1234
1235 val = (enable) ? 1 : 0;
1236 halbtc8703b1ant_ltecoex_indirect_write_reg(btcoexist, 0x38, 0x80,
1237 val); /* 0x38[7] */
1238
1239 }
1240
halbtc8703b1ant_ltecoex_pathcontrol_owner(IN struct btc_coexist * btcoexist,IN boolean wifi_control)1241 void halbtc8703b1ant_ltecoex_pathcontrol_owner(IN struct btc_coexist *btcoexist,
1242 IN boolean wifi_control)
1243 {
1244 u8 val;
1245
1246 val = (wifi_control) ? 1 : 0;
1247 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x4,
1248 val); /* 0x70[26] */
1249
1250 }
1251
halbtc8703b1ant_ltecoex_set_gnt_bt(IN struct btc_coexist * btcoexist,IN u8 control_block,IN boolean sw_control,IN u8 state)1252 void halbtc8703b1ant_ltecoex_set_gnt_bt(IN struct btc_coexist *btcoexist,
1253 IN u8 control_block, IN boolean sw_control, IN u8 state)
1254 {
1255 u32 val = 0, val_orig = 0;
1256
1257 if (!sw_control)
1258 val = 0x0;
1259 else if (state & 0x1)
1260 val = 0x3;
1261 else
1262 val = 0x1;
1263
1264 val_orig = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
1265 0x38);
1266
1267 switch (control_block) {
1268 case BT_8703B_1ANT_GNT_BLOCK_RFC_BB:
1269 default:
1270 val = ((val << 14) | (val << 10)) | (val_orig & 0xffff33ff);
1271 break;
1272 case BT_8703B_1ANT_GNT_BLOCK_RFC:
1273 val = (val << 14) | (val_orig & 0xffff3fff);
1274 break;
1275 case BT_8703B_1ANT_GNT_BLOCK_BB:
1276 val = (val << 10) | (val_orig & 0xfffff3ff);
1277 break;
1278 }
1279
1280 halbtc8703b1ant_ltecoex_indirect_write_reg(btcoexist,
1281 0x38, 0xffffffff, val);
1282 }
1283
1284
halbtc8703b1ant_ltecoex_set_gnt_wl(IN struct btc_coexist * btcoexist,IN u8 control_block,IN boolean sw_control,IN u8 state)1285 void halbtc8703b1ant_ltecoex_set_gnt_wl(IN struct btc_coexist *btcoexist,
1286 IN u8 control_block, IN boolean sw_control, IN u8 state)
1287 {
1288 u32 val = 0, val_orig = 0;
1289
1290 if (!sw_control)
1291 val = 0x0;
1292 else if (state & 0x1)
1293 val = 0x3;
1294 else
1295 val = 0x1;
1296
1297 val_orig = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
1298 0x38);
1299
1300 switch (control_block) {
1301 case BT_8703B_1ANT_GNT_BLOCK_RFC_BB:
1302 default:
1303 val = ((val << 12) | (val << 8)) | (val_orig & 0xffffccff);
1304 break;
1305 case BT_8703B_1ANT_GNT_BLOCK_RFC:
1306 val = (val << 12) | (val_orig & 0xffffcfff);
1307 break;
1308 case BT_8703B_1ANT_GNT_BLOCK_BB:
1309 val = (val << 8) | (val_orig & 0xfffffcff);
1310 break;
1311 }
1312
1313 halbtc8703b1ant_ltecoex_indirect_write_reg(btcoexist,
1314 0x38, 0xffffffff, val);
1315 }
1316
1317
halbtc8703b1ant_ltecoex_set_coex_table(IN struct btc_coexist * btcoexist,IN u8 table_type,IN u16 table_content)1318 void halbtc8703b1ant_ltecoex_set_coex_table(IN struct btc_coexist *btcoexist,
1319 IN u8 table_type, IN u16 table_content)
1320 {
1321 u16 reg_addr = 0x0000;
1322
1323 switch (table_type) {
1324 case BT_8703B_1ANT_CTT_WL_VS_LTE:
1325 reg_addr = 0xa0;
1326 break;
1327 case BT_8703B_1ANT_CTT_BT_VS_LTE:
1328 reg_addr = 0xa4;
1329 break;
1330 }
1331
1332 if (reg_addr != 0x0000)
1333 halbtc8703b1ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1334 0xffff, table_content); /* 0xa0[15:0] or 0xa4[15:0] */
1335
1336
1337 }
1338
1339
halbtc8703b1ant_ltecoex_set_break_table(IN struct btc_coexist * btcoexist,IN u8 table_type,IN u8 table_content)1340 void halbtc8703b1ant_ltecoex_set_break_table(IN struct btc_coexist *btcoexist,
1341 IN u8 table_type, IN u8 table_content)
1342 {
1343 u16 reg_addr = 0x0000;
1344
1345 switch (table_type) {
1346 case BT_8703B_1ANT_LBTT_WL_BREAK_LTE:
1347 reg_addr = 0xa8;
1348 break;
1349 case BT_8703B_1ANT_LBTT_BT_BREAK_LTE:
1350 reg_addr = 0xac;
1351 break;
1352 case BT_8703B_1ANT_LBTT_LTE_BREAK_WL:
1353 reg_addr = 0xb0;
1354 break;
1355 case BT_8703B_1ANT_LBTT_LTE_BREAK_BT:
1356 reg_addr = 0xb4;
1357 break;
1358 }
1359
1360 if (reg_addr != 0x0000)
1361 halbtc8703b1ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1362 0xff, table_content); /* 0xa8[15:0] or 0xb4[15:0] */
1363
1364
1365 }
1366
halbtc8703b1ant_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)1367 void halbtc8703b1ant_set_wltoggle_coex_table(IN struct btc_coexist *btcoexist,
1368 IN boolean force_exec, IN u8 interval,
1369 IN u8 val0x6c4_b0, IN u8 val0x6c4_b1, IN u8 val0x6c4_b2,
1370 IN u8 val0x6c4_b3)
1371 {
1372 static u8 pre_h2c_parameter[6] = {0};
1373 u8 cur_h2c_parameter[6] = {0};
1374 u8 i, match_cnt = 0;
1375
1376 cur_h2c_parameter[0] = 0x7; /* op_code, 0x7= wlan toggle slot*/
1377
1378 cur_h2c_parameter[1] = interval;
1379 cur_h2c_parameter[2] = val0x6c4_b0;
1380 cur_h2c_parameter[3] = val0x6c4_b1;
1381 cur_h2c_parameter[4] = val0x6c4_b2;
1382 cur_h2c_parameter[5] = val0x6c4_b3;
1383
1384 if (!force_exec) {
1385 for (i = 1; i <= 5; i++) {
1386 if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
1387 break;
1388
1389 match_cnt++;
1390 }
1391
1392 if (match_cnt == 5)
1393 return;
1394 }
1395
1396 for (i = 1; i <= 5; i++)
1397 pre_h2c_parameter[i] = cur_h2c_parameter[i];
1398
1399 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, cur_h2c_parameter);
1400 }
1401
1402
halbtc8703b1ant_set_coex_table(IN struct btc_coexist * btcoexist,IN u32 val0x6c0,IN u32 val0x6c4,IN u32 val0x6c8,IN u8 val0x6cc)1403 void halbtc8703b1ant_set_coex_table(IN struct btc_coexist *btcoexist,
1404 IN u32 val0x6c0, IN u32 val0x6c4, IN u32 val0x6c8, IN u8 val0x6cc)
1405 {
1406 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
1407
1408 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
1409
1410 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
1411
1412 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
1413 }
1414
halbtc8703b1ant_coex_table(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u32 val0x6c0,IN u32 val0x6c4,IN u32 val0x6c8,IN u8 val0x6cc)1415 void halbtc8703b1ant_coex_table(IN struct btc_coexist *btcoexist,
1416 IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
1417 IN u32 val0x6c8, IN u8 val0x6cc)
1418 {
1419 coex_dm->cur_val0x6c0 = val0x6c0;
1420 coex_dm->cur_val0x6c4 = val0x6c4;
1421 coex_dm->cur_val0x6c8 = val0x6c8;
1422 coex_dm->cur_val0x6cc = val0x6cc;
1423
1424 if (!force_exec) {
1425 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1426 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1427 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1428 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1429 return;
1430 }
1431 halbtc8703b1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1432 val0x6cc);
1433
1434 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1435 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1436 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1437 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1438 }
1439
halbtc8703b1ant_coex_table_with_type(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)1440 void halbtc8703b1ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
1441 IN boolean force_exec, IN u8 type)
1442 {
1443 u32 break_table;
1444 u8 select_table;
1445
1446 coex_sta->coex_table_type = type;
1447
1448 if (coex_sta->concurrent_rx_mode_on == TRUE) {
1449 break_table = 0xf0ffffff; /* set WL hi-pri can break BT */
1450 select_table =
1451 0xb; /* set Tx response = Hi-Pri (ex: Transmitting ACK,BA,CTS) */
1452 } else {
1453 break_table = 0xffffff;
1454 select_table = 0x3;
1455 }
1456
1457 switch (type) {
1458 case 0:
1459 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1460 0x55555555, 0x55555555, break_table,
1461 select_table);
1462 break;
1463 case 1:
1464 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1465 0xa5555555, 0xaa5a5a5a, break_table,
1466 select_table);
1467 break;
1468 case 2:
1469 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1470 0xaa5a5a5a, 0xaa5a5a5a, break_table,
1471 select_table);
1472 break;
1473 case 3:
1474 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1475 0x55555555, 0x5a5a5a5a, break_table,
1476 select_table);
1477 break;
1478 case 4:
1479 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1480 0xa5555555, 0xaa5a5a5a, break_table,
1481 select_table);
1482 break;
1483 case 5:
1484 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1485 0x5a5a5a5a, 0x5a5a5a5a, break_table,
1486 select_table);
1487 break;
1488 case 6:
1489 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1490 0xa5555555, 0xaa5a5a5a, break_table,
1491 select_table);
1492 break;
1493 case 7:
1494 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1495 0xaa555555, 0xaa555555, break_table,
1496 select_table);
1497 break;
1498 case 8:
1499 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1500 0xa5555555, 0xaaaa5aaa, break_table,
1501 select_table);
1502 break;
1503 case 9:
1504 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1505 0x5a5a5a5a, 0xaaaa5aaa, break_table,
1506 select_table);
1507 break;
1508 case 10:
1509 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1510 0xaaaaaaaa, 0xaaaaaaaa, break_table,
1511 select_table);
1512 break;
1513 case 11:
1514 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1515 0xa5a55555, 0xaaaa5a5a, break_table,
1516 select_table);
1517 break;
1518 case 12:
1519 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1520 0xa5555555, 0xaaaa5a5a, break_table,
1521 select_table);
1522 break;
1523 case 13:
1524 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1525 0xaa5555aa, 0xaa5a5a5a, break_table,
1526 select_table);
1527 break;
1528 case 14:
1529 halbtc8703b1ant_coex_table(btcoexist, force_exec,
1530 0xaa5555aa, 0x5a5a5a5a, break_table,
1531 select_table);
1532 break;
1533 default:
1534 break;
1535 }
1536 }
1537
halbtc8703b1ant_set_fw_ignore_wlan_act(IN struct btc_coexist * btcoexist,IN boolean enable)1538 void halbtc8703b1ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1539 IN boolean enable)
1540 {
1541 u8 h2c_parameter[1] = {0};
1542
1543 if (enable)
1544 h2c_parameter[0] |= BIT(0);/* function enable */
1545
1546 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1547 }
1548
halbtc8703b1ant_ignore_wlan_act(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean enable)1549 void halbtc8703b1ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1550 IN boolean force_exec, IN boolean enable)
1551 {
1552 coex_dm->cur_ignore_wlan_act = enable;
1553
1554 if (!force_exec) {
1555 if (coex_dm->pre_ignore_wlan_act ==
1556 coex_dm->cur_ignore_wlan_act)
1557 return;
1558 }
1559 halbtc8703b1ant_set_fw_ignore_wlan_act(btcoexist, enable);
1560
1561 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1562 }
1563
halbtc8703b1ant_set_lps_rpwm(IN struct btc_coexist * btcoexist,IN u8 lps_val,IN u8 rpwm_val)1564 void halbtc8703b1ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
1565 IN u8 lps_val, IN u8 rpwm_val)
1566 {
1567 u8 lps = lps_val;
1568 u8 rpwm = rpwm_val;
1569
1570 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1571 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1572 }
1573
halbtc8703b1ant_lps_rpwm(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 lps_val,IN u8 rpwm_val)1574 void halbtc8703b1ant_lps_rpwm(IN struct btc_coexist *btcoexist,
1575 IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
1576 {
1577 coex_dm->cur_lps = lps_val;
1578 coex_dm->cur_rpwm = rpwm_val;
1579
1580 if (!force_exec) {
1581 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1582 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1583 return;
1584 }
1585 halbtc8703b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1586
1587 coex_dm->pre_lps = coex_dm->cur_lps;
1588 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1589 }
1590
halbtc8703b1ant_ps_tdma_check_for_power_save_state(IN struct btc_coexist * btcoexist,IN boolean new_ps_state)1591 void halbtc8703b1ant_ps_tdma_check_for_power_save_state(
1592 IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
1593 {
1594 u8 lps_mode = 0x0;
1595 u8 h2c_parameter[5] = {0x8, 0, 0, 0, 0};
1596
1597 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1598
1599 if (lps_mode) { /* already under LPS state */
1600 if (new_ps_state) {
1601 /* keep state under LPS, do nothing. */
1602 } else {
1603 /* will leave LPS state, turn off psTdma first */
1604 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1605 h2c_parameter);
1606 }
1607 } else { /* NO PS state */
1608 if (new_ps_state) {
1609 /* will enter LPS state, turn off psTdma first */
1610 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1611 h2c_parameter);
1612 } else {
1613 /* keep state under NO PS state, do nothing. */
1614 }
1615 }
1616 }
1617
halbtc8703b1ant_power_save_state(IN struct btc_coexist * btcoexist,IN u8 ps_type,IN u8 lps_val,IN u8 rpwm_val)1618 void halbtc8703b1ant_power_save_state(IN struct btc_coexist *btcoexist,
1619 IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
1620 {
1621 boolean low_pwr_disable = FALSE;
1622
1623 switch (ps_type) {
1624 case BTC_PS_WIFI_NATIVE:
1625 /* recover to original 32k low power setting */
1626 coex_sta->force_lps_ctrl = FALSE;
1627 low_pwr_disable = FALSE;
1628 /* btcoexist->btc_set(btcoexist,
1629 BTC_SET_ACT_DISABLE_LOW_POWER,
1630 &low_pwr_disable); */
1631 btcoexist->btc_set(btcoexist, BTC_SET_ACT_PRE_NORMAL_LPS,
1632 NULL);
1633
1634 break;
1635 case BTC_PS_LPS_ON:
1636 coex_sta->force_lps_ctrl = TRUE;
1637 halbtc8703b1ant_ps_tdma_check_for_power_save_state(
1638 btcoexist, TRUE);
1639 halbtc8703b1ant_lps_rpwm(btcoexist, NORMAL_EXEC,
1640 lps_val, rpwm_val);
1641 /* when coex force to enter LPS, do not enter 32k low power. */
1642 low_pwr_disable = TRUE;
1643 btcoexist->btc_set(btcoexist,
1644 BTC_SET_ACT_DISABLE_LOW_POWER,
1645 &low_pwr_disable);
1646 /* power save must executed before psTdma. */
1647 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
1648 NULL);
1649
1650 break;
1651 case BTC_PS_LPS_OFF:
1652 coex_sta->force_lps_ctrl = TRUE;
1653 halbtc8703b1ant_ps_tdma_check_for_power_save_state(
1654 btcoexist, FALSE);
1655 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1656 NULL);
1657
1658 break;
1659 default:
1660 break;
1661 }
1662 }
1663
1664
1665
halbtc8703b1ant_set_fw_pstdma(IN struct btc_coexist * btcoexist,IN u8 byte1,IN u8 byte2,IN u8 byte3,IN u8 byte4,IN u8 byte5)1666 void halbtc8703b1ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
1667 IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
1668 {
1669 u8 h2c_parameter[5] = {0};
1670 u8 real_byte1 = byte1, real_byte5 = byte5;
1671 boolean ap_enable = FALSE;
1672 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1673 u8 ps_type = BTC_PS_WIFI_NATIVE;
1674
1675 if (byte5 & BIT(2))
1676 coex_sta->is_tdma_btautoslot = TRUE;
1677 else
1678 coex_sta->is_tdma_btautoslot = FALSE;
1679
1680 /* release bt-auto slot for auto-slot hang is detected!! */
1681 if (coex_sta->is_tdma_btautoslot)
1682 if ((coex_sta->is_tdma_btautoslot_hang) ||
1683 (bt_link_info->slave_role))
1684 byte5 = byte5 & 0xfb;
1685
1686 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1687 &ap_enable);
1688
1689 if ((ap_enable) && (byte1 & BIT(4) && !(byte1 & BIT(5)))) {
1690 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1691 "[BTCoex], FW for AP mode\n");
1692 BTC_TRACE(trace_buf);
1693 real_byte1 &= ~BIT(4);
1694 real_byte1 |= BIT(5);
1695
1696 real_byte5 |= BIT(5);
1697 real_byte5 &= ~BIT(6);
1698
1699 ps_type = BTC_PS_WIFI_NATIVE;
1700 halbtc8703b1ant_power_save_state(btcoexist,
1701 ps_type, 0x0,
1702 0x0);
1703 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1704
1705 ps_type = BTC_PS_LPS_ON;
1706 halbtc8703b1ant_power_save_state(
1707 btcoexist, ps_type, 0x50,
1708 0x4);
1709 } else {
1710 ps_type = BTC_PS_WIFI_NATIVE;
1711 halbtc8703b1ant_power_save_state(btcoexist, ps_type,
1712 0x0,
1713 0x0);
1714 }
1715
1716 h2c_parameter[0] = real_byte1;
1717 h2c_parameter[1] = byte2;
1718 h2c_parameter[2] = byte3;
1719 h2c_parameter[3] = byte4;
1720 h2c_parameter[4] = real_byte5;
1721
1722 coex_dm->ps_tdma_para[0] = real_byte1;
1723 coex_dm->ps_tdma_para[1] = byte2;
1724 coex_dm->ps_tdma_para[2] = byte3;
1725 coex_dm->ps_tdma_para[3] = byte4;
1726 coex_dm->ps_tdma_para[4] = real_byte5;
1727
1728 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1729
1730 if (ps_type == BTC_PS_WIFI_NATIVE)
1731 btcoexist->btc_set(btcoexist, BTC_SET_ACT_POST_NORMAL_LPS, NULL);
1732 }
1733
1734
halbtc8703b1ant_ps_tdma(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean turn_on,IN u8 type)1735 void halbtc8703b1ant_ps_tdma(IN struct btc_coexist *btcoexist,
1736 IN boolean force_exec, IN boolean turn_on, IN u8 type)
1737 {
1738 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1739 boolean wifi_busy = FALSE;
1740 u8 rssi_adjust_val = 0;
1741 static u8 psTdmaByte4Modify = 0x0, pre_psTdmaByte4Modify = 0x0;
1742 static boolean pre_wifi_busy = FALSE;
1743
1744 coex_dm->cur_ps_tdma_on = turn_on;
1745 coex_dm->cur_ps_tdma = type;
1746
1747 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1748
1749 if (wifi_busy != pre_wifi_busy) {
1750 force_exec = TRUE;
1751 pre_wifi_busy = wifi_busy;
1752 }
1753
1754 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1755 if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1756 psTdmaByte4Modify = 0x1;
1757 else
1758 psTdmaByte4Modify = 0x0;
1759
1760 if (pre_psTdmaByte4Modify != psTdmaByte4Modify) {
1761
1762 force_exec = TRUE;
1763 pre_psTdmaByte4Modify = psTdmaByte4Modify;
1764 }
1765
1766 if (!force_exec) {
1767 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1768 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1769 return;
1770 }
1771
1772 if (coex_dm->cur_ps_tdma_on) {
1773 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1774 "[BTCoex], ********** TDMA(on, %d) **********\n",
1775 coex_dm->cur_ps_tdma);
1776 BTC_TRACE(trace_buf);
1777 } else {
1778 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1779 "[BTCoex], ********** TDMA(off, %d) **********\n",
1780 coex_dm->cur_ps_tdma);
1781 BTC_TRACE(trace_buf);
1782 }
1783
1784 if (turn_on) {
1785
1786 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
1787 0x1); /* enable TBTT nterrupt */
1788 }
1789
1790
1791 if (turn_on) {
1792 switch (type) {
1793 default:
1794 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1795 0x61, 0x35, 0x03, 0x11, 0x11);
1796 break;
1797 case 3:
1798 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1799 0x51, 0x30, 0x03, 0x10, 0x50);
1800 break;
1801 case 4:
1802 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1803 0x51, 0x21, 0x03, 0x10, 0x50);
1804 break;
1805 case 5:
1806 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1807 0x61, 0x3a, 0x03, 0x11, 0x11);
1808 break;
1809 case 6:
1810 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1811 0x61, 0x20, 0x03, 0x11, 0x11);
1812 break;
1813 case 7:
1814 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1815 0x51, 0x10, 0x03, 0x10, 0x54 |
1816 psTdmaByte4Modify);
1817 break;
1818 case 8:
1819 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1820 0x51, 0x10, 0x03, 0x10, 0x54 |
1821 psTdmaByte4Modify);
1822 break;
1823 case 9:
1824 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1825 0x51, 0x10, 0x03, 0x10, 0x54 |
1826 psTdmaByte4Modify);
1827 break;
1828 case 10:
1829 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1830 0x61, 0x30, 0x03, 0x11, 0x10);
1831 break;
1832 case 11:
1833 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1834 0x61, 0x25, 0x03, 0x11, 0x11 |
1835 psTdmaByte4Modify);
1836 break;
1837 case 12:
1838 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1839 0x51, 0x35, 0x03, 0x10, 0x50 |
1840 psTdmaByte4Modify);
1841 break;
1842 case 13:
1843 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1844 0x51, 0x25, 0x03, 0x10, 0x50 |
1845 psTdmaByte4Modify);
1846 break;
1847 case 14:
1848 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1849 0x51, 0x15, 0x03, 0x10, 0x50 |
1850 psTdmaByte4Modify);
1851 break;
1852 case 15:
1853 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1854 0x51, 0x20, 0x03, 0x10, 0x50 |
1855 psTdmaByte4Modify);
1856 break;
1857 case 16:
1858 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1859 0x61, 0x10, 0x03, 0x11, 0x15 |
1860 psTdmaByte4Modify);
1861 break;
1862 case 17:
1863 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1864 0x61, 0x10, 0x03, 0x11, 0x14);
1865 break;
1866 case 18:
1867 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1868 0x51, 0x30, 0x03, 0x10, 0x50 |
1869 psTdmaByte4Modify);
1870 break;
1871 case 19:
1872 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1873 0x61, 0x15, 0x03, 0x11, 0x10);
1874 break;
1875 case 20:
1876 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1877 0x61, 0x30, 0x03, 0x11, 0x10);
1878 break;
1879 case 21:
1880 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1881 0x61, 0x30, 0x03, 0x11, 0x10);
1882 break;
1883 case 22:
1884 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1885 0x61, 0x25, 0x03, 0x11, 0x10);
1886 break;
1887 case 24:
1888 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1889 0x51, 0x08, 0x03, 0x10, 0x54 |
1890 psTdmaByte4Modify);
1891 break;
1892 case 27:
1893 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1894 0x61, 0x10, 0x03, 0x11, 0x15);
1895 break;
1896 case 28:
1897 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1898 0x51, 0x10, 0x0b, 0x10, 0x54);
1899 break;
1900 case 32:
1901 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1902 0x61, 0x35, 0x03, 0x11, 0x11);
1903 break;
1904 case 33:
1905 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1906 0x61, 0x35, 0x03, 0x11, 0x10);
1907 break;
1908 case 36:
1909 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1910 0x61, 0x48, 0x03, 0x11, 0x10);
1911 break;
1912 case 57:
1913 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1914 0x51, 0x10, 0x03, 0x10, 0x50 |
1915 psTdmaByte4Modify);
1916 break;
1917 case 58:
1918 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1919 0x51, 0x10, 0x03, 0x10, 0x50 |
1920 psTdmaByte4Modify);
1921 break;
1922 case 67:
1923 halbtc8703b1ant_set_fw_pstdma(btcoexist,
1924 0x61, 0x10, 0x03, 0x11, 0x10 |
1925 psTdmaByte4Modify);
1926 break;
1927 }
1928 } else {
1929
1930 /* disable PS tdma */
1931 switch (type) {
1932 case 8: /* PTA Control */
1933 halbtc8703b1ant_set_fw_pstdma(btcoexist, 0x8,
1934 0x0, 0x0, 0x0, 0x0);
1935 break;
1936 case 0:
1937 default: /* Software control, Antenna at BT side */
1938 halbtc8703b1ant_set_fw_pstdma(btcoexist, 0x0,
1939 0x0, 0x0, 0x0, 0x0);
1940 break;
1941 case 1: /* 2-Ant, 0x778=3, antenna control by antenna diversity */
1942 halbtc8703b1ant_set_fw_pstdma(btcoexist, 0x0,
1943 0x0, 0x0, 0x48, 0x0);
1944 break;
1945 }
1946 }
1947
1948 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1949 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1950
1951 }
1952
halbtc8703b1ant_set_ant_path(IN struct btc_coexist * btcoexist,IN u8 ant_pos_type,IN boolean force_exec,IN u8 phase)1953 void halbtc8703b1ant_set_ant_path(IN struct btc_coexist *btcoexist,
1954 IN u8 ant_pos_type, IN boolean force_exec,
1955 IN u8 phase)
1956 {
1957 u32 cnt_bt_cal_chk = 0;
1958 boolean is_in_mp_mode = FALSE;
1959 u8 u8tmp = 0;
1960 u32 u32tmp1 = 0, u32tmp2 = 0;
1961
1962
1963 u32tmp1 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
1964 0x38);
1965
1966 /* To avoid indirect access fail */
1967 if (((u32tmp1 & 0xf000) >> 12) != ((u32tmp1 & 0x0f00) >> 8)) {
1968 force_exec = TRUE;
1969 coex_sta->gnt_error_cnt++;
1970 }
1971
1972 #if 1
1973 u32tmp2 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
1974 0x54);
1975 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x73);
1976
1977 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1978 "[BTCoex], ********** (Before Ant Setup) 0x73 = 0x%x, 0x38= 0x%x, 0x54= 0x%x**********\n",
1979 u8tmp, u32tmp1, u32tmp2);
1980 BTC_TRACE(trace_buf);
1981 #endif
1982
1983 coex_dm->cur_ant_pos_type = ant_pos_type;
1984
1985 if (!force_exec) {
1986 if (coex_dm->cur_ant_pos_type == coex_dm->pre_ant_pos_type) {
1987
1988 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1989 "[BTCoex], ********** Skip Antenna Path Setup because no change!!**********\n");
1990 BTC_TRACE(trace_buf);
1991 return;
1992 }
1993 }
1994
1995 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
1996
1997 switch (phase) {
1998 case BT_8703B_1ANT_PHASE_COEX_INIT:
1999 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
2000 halbtc8703b1ant_ltecoex_enable(btcoexist, 0x0);
2001
2002 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
2003 halbtc8703b1ant_ltecoex_set_coex_table(
2004 btcoexist,
2005 BT_8703B_1ANT_CTT_WL_VS_LTE,
2006 0xffff);
2007
2008 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
2009 halbtc8703b1ant_ltecoex_set_coex_table(
2010 btcoexist,
2011 BT_8703B_1ANT_CTT_BT_VS_LTE,
2012 0xffff);
2013
2014 /* Wait If BT IQK running, because Path control owner is at BT during BT IQK (setup by WiFi firmware) */
2015 while (cnt_bt_cal_chk <= 20) {
2016 u8tmp = btcoexist->btc_read_1byte(
2017 btcoexist,
2018 0x49d);
2019 cnt_bt_cal_chk++;
2020 if (u8tmp & BIT(0)) {
2021 BTC_SPRINTF(trace_buf,
2022 BT_TMP_BUF_SIZE,
2023 "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
2024 cnt_bt_cal_chk);
2025 BTC_TRACE(trace_buf);
2026 delay_ms(50);
2027 } else {
2028 BTC_SPRINTF(trace_buf,
2029 BT_TMP_BUF_SIZE,
2030 "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
2031 cnt_bt_cal_chk);
2032 BTC_TRACE(trace_buf);
2033 break;
2034 }
2035 }
2036
2037
2038 /* set Path control owner to WL at initial step */
2039 halbtc8703b1ant_ltecoex_pathcontrol_owner(
2040 btcoexist,
2041 BT_8703B_1ANT_PCO_WLSIDE);
2042
2043 /* set GNT_BT to SW high */
2044 halbtc8703b1ant_ltecoex_set_gnt_bt(btcoexist,
2045 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2046 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
2047 BT_8703B_1ANT_SIG_STA_SET_TO_HIGH);
2048 /* Set GNT_WL to SW low */
2049 halbtc8703b1ant_ltecoex_set_gnt_wl(btcoexist,
2050 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2051 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
2052 BT_8703B_1ANT_SIG_STA_SET_TO_LOW);
2053
2054 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2055 ant_pos_type = BTC_ANT_PATH_BT;
2056
2057 coex_sta->run_time_state = FALSE;
2058 break;
2059 case BT_8703B_1ANT_PHASE_WLANONLY_INIT:
2060 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
2061 halbtc8703b1ant_ltecoex_enable(btcoexist, 0x0);
2062
2063 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
2064 halbtc8703b1ant_ltecoex_set_coex_table(
2065 btcoexist,
2066 BT_8703B_1ANT_CTT_WL_VS_LTE,
2067 0xffff);
2068
2069 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
2070 halbtc8703b1ant_ltecoex_set_coex_table(
2071 btcoexist,
2072 BT_8703B_1ANT_CTT_BT_VS_LTE,
2073 0xffff);
2074
2075 /* set Path control owner to WL at initial step */
2076 halbtc8703b1ant_ltecoex_pathcontrol_owner(
2077 btcoexist,
2078 BT_8703B_1ANT_PCO_WLSIDE);
2079
2080 /* set GNT_BT to SW low */
2081 halbtc8703b1ant_ltecoex_set_gnt_bt(btcoexist,
2082 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2083 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
2084 BT_8703B_1ANT_SIG_STA_SET_TO_LOW);
2085 /* Set GNT_WL to SW high */
2086 halbtc8703b1ant_ltecoex_set_gnt_wl(btcoexist,
2087 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2088 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
2089 BT_8703B_1ANT_SIG_STA_SET_TO_HIGH);
2090
2091 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2092 ant_pos_type =
2093 BTC_ANT_PATH_WIFI;
2094
2095 coex_sta->run_time_state = FALSE;
2096 break;
2097 case BT_8703B_1ANT_PHASE_WLAN_OFF:
2098 /* Disable LTE Coex Function in WiFi side */
2099 halbtc8703b1ant_ltecoex_enable(btcoexist, 0x0);
2100
2101 /* set Path control owner to BT */
2102 halbtc8703b1ant_ltecoex_pathcontrol_owner(
2103 btcoexist,
2104 BT_8703B_1ANT_PCO_BTSIDE);
2105
2106 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2107 ant_pos_type = BTC_ANT_PATH_BT;
2108
2109 coex_sta->run_time_state = FALSE;
2110 break;
2111 case BT_8703B_1ANT_PHASE_2G_RUNTIME:
2112 halbtc8703b1ant_ltecoex_pathcontrol_owner(
2113 btcoexist,
2114 BT_8703B_1ANT_PCO_WLSIDE);
2115
2116 /* set GNT_BT to PTA */
2117 halbtc8703b1ant_ltecoex_set_gnt_bt(btcoexist,
2118 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2119 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_PTA,
2120 BT_8703B_1ANT_SIG_STA_SET_BY_HW);
2121 /* Set GNT_WL to PTA */
2122 halbtc8703b1ant_ltecoex_set_gnt_wl(btcoexist,
2123 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2124 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_PTA,
2125 BT_8703B_1ANT_SIG_STA_SET_BY_HW);
2126
2127 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2128 ant_pos_type = BTC_ANT_PATH_PTA;
2129
2130 coex_sta->run_time_state = TRUE;
2131 break;
2132 case BT_8703B_1ANT_PHASE_BTMPMODE:
2133 halbtc8703b1ant_ltecoex_pathcontrol_owner(
2134 btcoexist,
2135 BT_8703B_1ANT_PCO_WLSIDE);
2136
2137 /* set GNT_BT to high */
2138 halbtc8703b1ant_ltecoex_set_gnt_bt(btcoexist,
2139 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2140 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
2141 BT_8703B_1ANT_SIG_STA_SET_TO_HIGH);
2142 /* Set GNT_WL to low */
2143 halbtc8703b1ant_ltecoex_set_gnt_wl(btcoexist,
2144 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
2145 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
2146 BT_8703B_1ANT_SIG_STA_SET_TO_LOW);
2147
2148 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2149 ant_pos_type = BTC_ANT_PATH_BT;
2150
2151 coex_sta->run_time_state = FALSE;
2152 break;
2153 }
2154
2155
2156 #if 1
2157 u32tmp1 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
2158 u32tmp2 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
2159 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x73);
2160
2161
2162 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2163 "[BTCoex], ********** (After Ant-Setup) 0x73 = 0x%x, 0x38= 0x%x, 0x54= 0x%x**********\n",
2164 u8tmp, u32tmp1, u32tmp2);
2165 BTC_TRACE(trace_buf);
2166
2167 #endif
2168 }
2169
2170
halbtc8703b1ant_is_common_action(IN struct btc_coexist * btcoexist)2171 boolean halbtc8703b1ant_is_common_action(IN struct btc_coexist *btcoexist)
2172 {
2173 boolean common = FALSE, wifi_connected = FALSE, wifi_busy = FALSE;
2174
2175 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2176 &wifi_connected);
2177 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2178
2179 if (!wifi_connected &&
2180 BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2181 coex_dm->bt_status) {
2182 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2183 "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
2184 BTC_TRACE(trace_buf);
2185 common = TRUE;
2186 } else if (wifi_connected &&
2187 (BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2188 coex_dm->bt_status)) {
2189 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2190 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
2191 BTC_TRACE(trace_buf);
2192 common = TRUE;
2193 } else if (!wifi_connected &&
2194 (BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2195 coex_dm->bt_status)) {
2196 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2197 "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
2198 BTC_TRACE(trace_buf);
2199 common = TRUE;
2200 } else if (wifi_connected &&
2201 (BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2202 coex_dm->bt_status)) {
2203 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2204 "[BTCoex], Wifi connected + BT connected-idle!!\n");
2205 BTC_TRACE(trace_buf);
2206 common = TRUE;
2207 } else if (!wifi_connected &&
2208 (BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE !=
2209 coex_dm->bt_status)) {
2210 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2211 "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
2212 BTC_TRACE(trace_buf);
2213 common = TRUE;
2214 } else {
2215 if (wifi_busy) {
2216 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2217 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
2218 BTC_TRACE(trace_buf);
2219 } else {
2220 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2221 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
2222 BTC_TRACE(trace_buf);
2223 }
2224
2225 common = FALSE;
2226 }
2227
2228 return common;
2229 }
2230
2231
2232 /* *********************************************
2233 *
2234 * Non-Software Coex Mechanism start
2235 *
2236 * ********************************************* */
halbtc8703b1ant_action_algorithm(IN struct btc_coexist * btcoexist)2237 u8 halbtc8703b1ant_action_algorithm(IN struct btc_coexist *btcoexist)
2238 {
2239 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2240 boolean bt_hs_on = FALSE;
2241 u8 algorithm = BT_8703B_1ANT_COEX_ALGO_UNDEFINED;
2242 u8 num_of_diff_profile = 0;
2243
2244 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2245
2246 if (!bt_link_info->bt_link_exist) {
2247 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2248 "[BTCoex], No BT link exists!!!\n");
2249 BTC_TRACE(trace_buf);
2250 return algorithm;
2251 }
2252
2253 if (bt_link_info->sco_exist)
2254 num_of_diff_profile++;
2255 if (bt_link_info->hid_exist)
2256 num_of_diff_profile++;
2257 if (bt_link_info->pan_exist)
2258 num_of_diff_profile++;
2259 if (bt_link_info->a2dp_exist)
2260 num_of_diff_profile++;
2261
2262 if (num_of_diff_profile == 1) {
2263 if (bt_link_info->sco_exist) {
2264 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2265 "[BTCoex], BT Profile = SCO only\n");
2266 BTC_TRACE(trace_buf);
2267 algorithm = BT_8703B_1ANT_COEX_ALGO_SCO;
2268 } else {
2269 if (bt_link_info->hid_exist) {
2270 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2271 "[BTCoex], BT Profile = HID only\n");
2272 BTC_TRACE(trace_buf);
2273 algorithm = BT_8703B_1ANT_COEX_ALGO_HID;
2274 } else if (bt_link_info->a2dp_exist) {
2275 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2276 "[BTCoex], BT Profile = A2DP only\n");
2277 BTC_TRACE(trace_buf);
2278 algorithm = BT_8703B_1ANT_COEX_ALGO_A2DP;
2279 } else if (bt_link_info->pan_exist) {
2280 if (bt_hs_on) {
2281 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2282 "[BTCoex], BT Profile = PAN(HS) only\n");
2283 BTC_TRACE(trace_buf);
2284 algorithm =
2285 BT_8703B_1ANT_COEX_ALGO_PANHS;
2286 } else {
2287 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2288 "[BTCoex], BT Profile = PAN(EDR) only\n");
2289 BTC_TRACE(trace_buf);
2290 algorithm =
2291 BT_8703B_1ANT_COEX_ALGO_PANEDR;
2292 }
2293 }
2294 }
2295 } else if (num_of_diff_profile == 2) {
2296 if (bt_link_info->sco_exist) {
2297 if (bt_link_info->hid_exist) {
2298 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2299 "[BTCoex], BT Profile = SCO + HID\n");
2300 BTC_TRACE(trace_buf);
2301 algorithm = BT_8703B_1ANT_COEX_ALGO_HID;
2302 } else if (bt_link_info->a2dp_exist) {
2303 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2304 "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
2305 BTC_TRACE(trace_buf);
2306 algorithm = BT_8703B_1ANT_COEX_ALGO_SCO;
2307 } else if (bt_link_info->pan_exist) {
2308 if (bt_hs_on) {
2309 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2310 "[BTCoex], BT Profile = SCO + PAN(HS)\n");
2311 BTC_TRACE(trace_buf);
2312 algorithm = BT_8703B_1ANT_COEX_ALGO_SCO;
2313 } else {
2314 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2315 "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
2316 BTC_TRACE(trace_buf);
2317 algorithm =
2318 BT_8703B_1ANT_COEX_ALGO_PANEDR_HID;
2319 }
2320 }
2321 } else {
2322 if (bt_link_info->hid_exist &&
2323 bt_link_info->a2dp_exist) {
2324 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2325 "[BTCoex], BT Profile = HID + A2DP\n");
2326 BTC_TRACE(trace_buf);
2327 algorithm = BT_8703B_1ANT_COEX_ALGO_HID_A2DP;
2328 } else if (bt_link_info->hid_exist &&
2329 bt_link_info->pan_exist) {
2330 if (bt_hs_on) {
2331 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2332 "[BTCoex], BT Profile = HID + PAN(HS)\n");
2333 BTC_TRACE(trace_buf);
2334 algorithm =
2335 BT_8703B_1ANT_COEX_ALGO_HID_A2DP;
2336 } else {
2337 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2338 "[BTCoex], BT Profile = HID + PAN(EDR)\n");
2339 BTC_TRACE(trace_buf);
2340 algorithm =
2341 BT_8703B_1ANT_COEX_ALGO_PANEDR_HID;
2342 }
2343 } else if (bt_link_info->pan_exist &&
2344 bt_link_info->a2dp_exist) {
2345 if (bt_hs_on) {
2346 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2347 "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
2348 BTC_TRACE(trace_buf);
2349 algorithm =
2350 BT_8703B_1ANT_COEX_ALGO_A2DP_PANHS;
2351 } else {
2352 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2353 "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
2354 BTC_TRACE(trace_buf);
2355 algorithm =
2356 BT_8703B_1ANT_COEX_ALGO_PANEDR_A2DP;
2357 }
2358 }
2359 }
2360 } else if (num_of_diff_profile == 3) {
2361 if (bt_link_info->sco_exist) {
2362 if (bt_link_info->hid_exist &&
2363 bt_link_info->a2dp_exist) {
2364 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2365 "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
2366 BTC_TRACE(trace_buf);
2367 algorithm = BT_8703B_1ANT_COEX_ALGO_HID;
2368 } else if (bt_link_info->hid_exist &&
2369 bt_link_info->pan_exist) {
2370 if (bt_hs_on) {
2371 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2372 "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
2373 BTC_TRACE(trace_buf);
2374 algorithm =
2375 BT_8703B_1ANT_COEX_ALGO_HID_A2DP;
2376 } else {
2377 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2378 "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
2379 BTC_TRACE(trace_buf);
2380 algorithm =
2381 BT_8703B_1ANT_COEX_ALGO_PANEDR_HID;
2382 }
2383 } else if (bt_link_info->pan_exist &&
2384 bt_link_info->a2dp_exist) {
2385 if (bt_hs_on) {
2386 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2387 "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
2388 BTC_TRACE(trace_buf);
2389 algorithm = BT_8703B_1ANT_COEX_ALGO_SCO;
2390 } else {
2391 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2392 "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
2393 BTC_TRACE(trace_buf);
2394 algorithm =
2395 BT_8703B_1ANT_COEX_ALGO_PANEDR_HID;
2396 }
2397 }
2398 } else {
2399 if (bt_link_info->hid_exist &&
2400 bt_link_info->pan_exist &&
2401 bt_link_info->a2dp_exist) {
2402 if (bt_hs_on) {
2403 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2404 "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
2405 BTC_TRACE(trace_buf);
2406 algorithm =
2407 BT_8703B_1ANT_COEX_ALGO_HID_A2DP;
2408 } else {
2409 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2410 "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
2411 BTC_TRACE(trace_buf);
2412 algorithm =
2413 BT_8703B_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
2414 }
2415 }
2416 }
2417 } else if (num_of_diff_profile >= 3) {
2418 if (bt_link_info->sco_exist) {
2419 if (bt_link_info->hid_exist &&
2420 bt_link_info->pan_exist &&
2421 bt_link_info->a2dp_exist) {
2422 if (bt_hs_on) {
2423 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2424 "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
2425 BTC_TRACE(trace_buf);
2426
2427 } else {
2428 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2429 "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
2430 BTC_TRACE(trace_buf);
2431 algorithm =
2432 BT_8703B_1ANT_COEX_ALGO_PANEDR_HID;
2433 }
2434 }
2435 }
2436 }
2437
2438 return algorithm;
2439 }
2440
halbtc8703b1ant_action_bt_whql_test(IN struct btc_coexist * btcoexist)2441 void halbtc8703b1ant_action_bt_whql_test(IN struct btc_coexist *btcoexist)
2442 {
2443 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
2444 BT_8703B_1ANT_PHASE_2G_RUNTIME);
2445 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2446 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 8);
2447 }
2448
halbtc8703b1ant_action_bt_hs(IN struct btc_coexist * btcoexist)2449 void halbtc8703b1ant_action_bt_hs(IN struct btc_coexist *btcoexist)
2450 {
2451 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2452 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 5);
2453 }
2454
halbtc8703b1ant_action_bt_relink(IN struct btc_coexist * btcoexist)2455 void halbtc8703b1ant_action_bt_relink(IN struct btc_coexist *btcoexist)
2456 {
2457 if (coex_sta->is_bt_multi_link == TRUE)
2458 return;
2459
2460 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2461 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 5);
2462 }
2463
halbtc8703b1ant_action_bt_idle(IN struct btc_coexist * btcoexist)2464 void halbtc8703b1ant_action_bt_idle(IN struct btc_coexist *btcoexist)
2465 {
2466 boolean wifi_busy = FALSE;
2467
2468 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2469
2470 if (!wifi_busy) {
2471 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2472 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 6);
2473 } else {/* if wl busy */
2474
2475 if (BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2476 coex_dm->bt_status) {
2477
2478 if (coex_sta->is_hiPri_rx_overhead)
2479 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2480 else
2481 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2482
2483 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 33);
2484 } else {
2485
2486 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2487 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 32);
2488 }
2489 }
2490 }
2491
halbtc8703b1ant_action_bt_inquiry(IN struct btc_coexist * btcoexist)2492 void halbtc8703b1ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
2493 {
2494 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2495 boolean wifi_connected = FALSE, ap_enable = FALSE, wifi_busy = FALSE,
2496 bt_busy = FALSE;
2497 boolean wifi_scan = FALSE, wifi_link = FALSE, wifi_roam = FALSE;
2498
2499 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
2500 &ap_enable);
2501 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2502 &wifi_connected);
2503 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2504 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2505 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
2506
2507 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
2508 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
2509
2510 if ((wifi_link) || (wifi_roam) || (coex_sta->wifi_is_high_pri_task)) {
2511
2512 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2513 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 33);
2514 } else if ((wifi_scan) && (coex_sta->bt_create_connection)) {
2515
2516 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2517 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 33);
2518 } else if ((!wifi_connected) && (!wifi_scan)) {
2519
2520 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2521 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 8);
2522 } else if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
2523
2524 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2525 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 6);
2526 } else if ((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) {
2527
2528 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2529 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 22);
2530 } else if (bt_link_info->a2dp_exist) {
2531
2532 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2533 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 32);
2534 } else if (wifi_scan) {
2535
2536 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2537 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 20);
2538 } else if (wifi_busy) {
2539
2540 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2541 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 21);
2542 } else {
2543
2544 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2545 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 21);
2546 }
2547 }
2548
halbtc8703b1ant_action_bt_sco_hid_only_busy(IN struct btc_coexist * btcoexist)2549 void halbtc8703b1ant_action_bt_sco_hid_only_busy(IN struct btc_coexist
2550 *btcoexist)
2551 {
2552 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2553 boolean wifi_connected = FALSE, wifi_busy = FALSE, wifi_cckdeadlock_ap = FALSE;
2554 u32 wifi_bw = 1;
2555 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2556
2557 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2558 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2559 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2560 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2561
2562 if ((iot_peer == BTC_IOT_PEER_ATHEROS) && (coex_sta->cck_lock_ever))
2563 wifi_cckdeadlock_ap = TRUE;
2564
2565 if (bt_link_info->sco_exist) {
2566 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2567 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 5);
2568 } else if (coex_sta->is_hid_rcu) {
2569 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2570
2571 if (wifi_busy)
2572 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 36);
2573 else
2574 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 6);
2575 } else {
2576
2577 if ((wifi_cckdeadlock_ap) && (coex_sta->is_bt_multi_link)) {
2578
2579 if (coex_sta->hid_busy_num < 2)
2580 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
2581 else
2582 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2583 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 18);
2584 } else if (coex_sta->is_bt_multi_link) {
2585 if (coex_sta->hid_busy_num < 2)
2586 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2587 else
2588 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
2589 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 18);
2590 } else if (coex_sta->hid_busy_num < 2) {
2591 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2592 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 11);
2593 } else if (wifi_bw == 0) { /* if 11bg mode */
2594
2595 if (coex_sta->is_bt_multi_link) {
2596 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2597 11);
2598 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 11);
2599 } else {
2600 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2601 11);
2602 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 11);
2603 }
2604 } else {
2605 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
2606 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 11);
2607 }
2608 }
2609 }
2610
2611
halbtc8703b1ant_action_wifi_only(IN struct btc_coexist * btcoexist)2612 void halbtc8703b1ant_action_wifi_only(IN struct btc_coexist *btcoexist)
2613 {
2614 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, FORCE_EXEC,
2615 BT_8703B_1ANT_PHASE_2G_RUNTIME);
2616 halbtc8703b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 10);
2617 halbtc8703b1ant_ps_tdma(btcoexist, FORCE_EXEC, FALSE, 8);
2618 }
2619
halbtc8703b1ant_action_wifi_native_lps(IN struct btc_coexist * btcoexist)2620 void halbtc8703b1ant_action_wifi_native_lps(IN struct btc_coexist *btcoexist)
2621 {
2622 halbtc8703b1ant_coex_table_with_type(btcoexist,
2623 NORMAL_EXEC, 5);
2624 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 8);
2625 }
2626
halbtc8703b1ant_action_wifi_cck_dead_lock(IN struct btc_coexist * btcoexist)2627 void halbtc8703b1ant_action_wifi_cck_dead_lock(IN struct btc_coexist *btcoexist)
2628 {
2629 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2630
2631 if ((bt_link_info->hid_exist) && (bt_link_info->a2dp_exist) &&
2632 (!bt_link_info->pan_exist)) {
2633
2634 if ((coex_sta->cck_lock) || (coex_sta->cck_lock_warn)) {
2635 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2636 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 28);
2637 } else {
2638
2639 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2640 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 8);
2641 }
2642 }
2643 }
2644
halbtc8703b1ant_action_wifi_multi_port(IN struct btc_coexist * btcoexist)2645 void halbtc8703b1ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
2646 {
2647 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2648
2649 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, NORMAL_EXEC,
2650 BT_8703B_1ANT_PHASE_2G_RUNTIME);
2651
2652 if ((BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2653 coex_dm->bt_status) ||
2654 (BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2655 coex_dm->bt_status))
2656 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2657 else if (!bt_link_info->pan_exist)
2658 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2659 else
2660 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2661
2662 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 8);
2663 }
2664
halbtc8703b1ant_action_wifi_linkscan_process(IN struct btc_coexist * btcoexist)2665 void halbtc8703b1ant_action_wifi_linkscan_process(IN struct btc_coexist
2666 *btcoexist)
2667 {
2668 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2669
2670 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2671
2672 if (bt_link_info->pan_exist)
2673 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 22);
2674 else if (bt_link_info->a2dp_exist)
2675 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 27);
2676 else
2677 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 21);
2678 }
2679
halbtc8703b1ant_action_wifi_connected_bt_acl_busy(IN struct btc_coexist * btcoexist)2680 void halbtc8703b1ant_action_wifi_connected_bt_acl_busy(IN struct btc_coexist
2681 *btcoexist)
2682 {
2683 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2684 boolean wifi_busy = FALSE, wifi_turbo = FALSE, wifi_cckdeadlock_ap = FALSE;
2685 u32 wifi_bw = 1;
2686 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2687
2688 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2689 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2690 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &coex_sta->scan_ap_num);
2691 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2692
2693 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2694 "############# [BTCoex], scan_ap_num = %d, wl_noisy_level = %d\n",
2695 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2696 BTC_TRACE(trace_buf);
2697
2698 if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2699 wifi_turbo = TRUE;
2700
2701 if ((iot_peer == BTC_IOT_PEER_ATHEROS) && (coex_sta->cck_lock_ever))
2702 wifi_cckdeadlock_ap = TRUE;
2703
2704 if ((bt_link_info->a2dp_exist) && (coex_sta->is_bt_a2dp_sink)) {
2705
2706 if (wifi_cckdeadlock_ap)
2707 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2708 else
2709 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
2710
2711 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 12);
2712 } else if (bt_link_info->a2dp_only) { /* A2DP */
2713
2714 if (wifi_cckdeadlock_ap)
2715 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2716 else if (wifi_turbo)
2717 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2718 else
2719 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2720
2721 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 7);
2722 } else if (((bt_link_info->a2dp_exist) &&
2723 (bt_link_info->pan_exist)) ||
2724 (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
2725 bt_link_info->pan_exist)) { /* A2DP+PAN(OPP,FTP), HID+A2DP+PAN(OPP,FTP) */
2726
2727 if (wifi_cckdeadlock_ap) {
2728 if ((bt_link_info->hid_exist) && (coex_sta->hid_busy_num < 2))
2729 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
2730 else
2731 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2732 } else if (bt_link_info->hid_exist) {
2733 if (coex_sta->hid_busy_num < 2)
2734 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2735 else
2736 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2737 } else if (wifi_turbo)
2738 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2739 else
2740 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2741
2742 if (wifi_busy)
2743 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 13);
2744 else
2745 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 14);
2746 } else if (bt_link_info->hid_exist &&
2747 bt_link_info->a2dp_exist) { /* HID+A2DP */
2748
2749 if (wifi_cckdeadlock_ap) {
2750 #if 1
2751 if (coex_sta->hid_busy_num < 2)
2752 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
2753 else
2754 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2755
2756 if (coex_sta->hid_pair_cnt > 1)
2757 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 24);
2758 else
2759 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 8);
2760 #endif
2761
2762 #if 0
2763 halbtc8703b1ant_action_wifi_cck_dead_lock(btcoexist);
2764 #endif
2765 } else {
2766 if (coex_sta->hid_busy_num < 2) /* 2/18 HID */
2767 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2768 else if (wifi_bw == 0)/* if 11bg mode */
2769 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
2770 else
2771 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2772
2773 if (coex_sta->hid_pair_cnt > 1)
2774 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 24);
2775 else
2776 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 8);
2777 }
2778 } else if ((bt_link_info->pan_only)
2779 || (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
2780 /* PAN(OPP,FTP), HID+PAN(OPP,FTP) */
2781
2782 if (wifi_cckdeadlock_ap) {
2783 if ((bt_link_info->hid_exist) && (coex_sta->hid_busy_num < 2))
2784 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
2785 else
2786 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2787 } else if (bt_link_info->hid_exist) {
2788 if (coex_sta->hid_busy_num < 2)
2789 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2790 else
2791 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2792 } else if (wifi_turbo)
2793 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2794 else
2795 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2796
2797 if (!wifi_busy)
2798 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 4);
2799 else
2800 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 3);
2801 } else {
2802 /* BT no-profile busy (0x9) */
2803 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2804 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 33);
2805 }
2806
2807 }
2808
2809
halbtc8703b1ant_action_wifi_not_connected(IN struct btc_coexist * btcoexist)2810 void halbtc8703b1ant_action_wifi_not_connected(IN struct btc_coexist *btcoexist)
2811 {
2812 /* tdma and coex table */
2813 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2814 halbtc8703b1ant_ps_tdma(btcoexist, FORCE_EXEC, FALSE, 8);
2815 }
2816
halbtc8703b1ant_action_wifi_connected(IN struct btc_coexist * btcoexist)2817 void halbtc8703b1ant_action_wifi_connected(IN struct btc_coexist *btcoexist)
2818 {
2819 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2820 boolean wifi_busy = FALSE;
2821
2822 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2823 "[BTCoex], CoexForWifiConnect()===>\n");
2824 BTC_TRACE(trace_buf);
2825
2826 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
2827 NORMAL_EXEC,
2828 BT_8703B_1ANT_PHASE_2G_RUNTIME);
2829
2830 if ((coex_dm->bt_status == BT_8703B_1ANT_BT_STATUS_ACL_BUSY) ||
2831 (coex_dm->bt_status == BT_8703B_1ANT_BT_STATUS_ACL_SCO_BUSY)) {
2832
2833 if (bt_link_info->hid_only)/* HID only */
2834 halbtc8703b1ant_action_bt_sco_hid_only_busy(btcoexist);
2835 else
2836 halbtc8703b1ant_action_wifi_connected_bt_acl_busy(btcoexist);
2837
2838 } else if (coex_dm->bt_status == BT_8703B_1ANT_BT_STATUS_SCO_BUSY)
2839 halbtc8703b1ant_action_bt_sco_hid_only_busy(btcoexist);
2840 else
2841 halbtc8703b1ant_action_bt_idle(btcoexist);
2842 }
2843
2844
halbtc8703b1ant_run_sw_coexist_mechanism(IN struct btc_coexist * btcoexist)2845 void halbtc8703b1ant_run_sw_coexist_mechanism(IN struct btc_coexist *btcoexist)
2846 {
2847 u8 algorithm = 0;
2848
2849 algorithm = halbtc8703b1ant_action_algorithm(btcoexist);
2850 coex_dm->cur_algorithm = algorithm;
2851
2852 if (halbtc8703b1ant_is_common_action(btcoexist)) {
2853
2854 } else {
2855 switch (coex_dm->cur_algorithm) {
2856 case BT_8703B_1ANT_COEX_ALGO_SCO:
2857 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2858 "[BTCoex], Action algorithm = SCO.\n");
2859 BTC_TRACE(trace_buf);
2860 break;
2861 case BT_8703B_1ANT_COEX_ALGO_HID:
2862 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2863 "[BTCoex], Action algorithm = HID.\n");
2864 BTC_TRACE(trace_buf);
2865 break;
2866 case BT_8703B_1ANT_COEX_ALGO_A2DP:
2867 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2868 "[BTCoex], Action algorithm = A2DP.\n");
2869 BTC_TRACE(trace_buf);
2870 break;
2871 case BT_8703B_1ANT_COEX_ALGO_A2DP_PANHS:
2872 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2873 "[BTCoex], Action algorithm = A2DP+PAN(HS).\n");
2874 BTC_TRACE(trace_buf);
2875 break;
2876 case BT_8703B_1ANT_COEX_ALGO_PANEDR:
2877 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2878 "[BTCoex], Action algorithm = PAN(EDR).\n");
2879 BTC_TRACE(trace_buf);
2880 break;
2881 case BT_8703B_1ANT_COEX_ALGO_PANHS:
2882 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2883 "[BTCoex], Action algorithm = HS mode.\n");
2884 BTC_TRACE(trace_buf);
2885 break;
2886 case BT_8703B_1ANT_COEX_ALGO_PANEDR_A2DP:
2887 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2888 "[BTCoex], Action algorithm = PAN+A2DP.\n");
2889 BTC_TRACE(trace_buf);
2890 break;
2891 case BT_8703B_1ANT_COEX_ALGO_PANEDR_HID:
2892 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2893 "[BTCoex], Action algorithm = PAN(EDR)+HID.\n");
2894 BTC_TRACE(trace_buf);
2895 break;
2896 case BT_8703B_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
2897 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2898 "[BTCoex], Action algorithm = HID+A2DP+PAN.\n");
2899 BTC_TRACE(trace_buf);
2900 break;
2901 case BT_8703B_1ANT_COEX_ALGO_HID_A2DP:
2902 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2903 "[BTCoex], Action algorithm = HID+A2DP.\n");
2904 BTC_TRACE(trace_buf);
2905 break;
2906 default:
2907 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2908 "[BTCoex], Action algorithm = coexist All Off!!\n");
2909 BTC_TRACE(trace_buf);
2910 break;
2911 }
2912 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
2913 }
2914 }
2915
halbtc8703b1ant_run_coexist_mechanism(IN struct btc_coexist * btcoexist)2916 void halbtc8703b1ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
2917 {
2918 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2919 boolean wifi_connected = FALSE, bt_hs_on = FALSE;
2920 boolean increase_scan_dev_num = FALSE;
2921 boolean bt_ctrl_agg_buf_size = FALSE;
2922 boolean miracast_plus_bt = FALSE, wifi_under_5g = FALSE;
2923 u8 agg_buf_size = 5;
2924 u32 wifi_link_status = 0;
2925 u32 num_of_wifi_link = 0, wifi_bw;
2926 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2927 boolean scan = FALSE, link = FALSE, roam = FALSE, under_4way = FALSE;
2928
2929 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2930 "[BTCoex], RunCoexistMechanism()===>\n");
2931 BTC_TRACE(trace_buf);
2932
2933 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2934 "[BTCoex], under_lps = %d, force_lps_ctrl = %d, acl_busy = %d!!!\n",
2935 coex_sta->under_lps, coex_sta->force_lps_ctrl, coex_sta->acl_busy);
2936 BTC_TRACE(trace_buf);
2937
2938 if (btcoexist->manual_control) {
2939 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2940 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
2941 BTC_TRACE(trace_buf);
2942 return;
2943 }
2944
2945 if (btcoexist->stop_coex_dm) {
2946 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2947 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
2948 BTC_TRACE(trace_buf);
2949 return;
2950 }
2951
2952 if (coex_sta->under_ips) {
2953 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2954 "[BTCoex], wifi is under IPS !!!\n");
2955 BTC_TRACE(trace_buf);
2956 return;
2957 }
2958
2959 if (!coex_sta->run_time_state) {
2960 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2961 "[BTCoex], return for run_time_state = FALSE !!!\n");
2962 BTC_TRACE(trace_buf);
2963 return;
2964 }
2965
2966 if (coex_sta->freeze_coexrun_by_btinfo) {
2967 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2968 "[BTCoex], return for freeze_coexrun_by_btinfo\n");
2969 BTC_TRACE(trace_buf);
2970 return;
2971 }
2972
2973 if ((coex_sta->under_lps) && (!coex_sta->force_lps_ctrl) &&
2974 (!coex_sta->acl_busy)) {
2975 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2976 "[BTCoex], RunCoexistMechanism(), wifi is under LPS !!!\n");
2977 BTC_TRACE(trace_buf);
2978 halbtc8703b1ant_action_wifi_native_lps(btcoexist);
2979 return;
2980 }
2981
2982 if (coex_sta->bt_whck_test) {
2983 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2984 "[BTCoex], BT is under WHCK TEST!!!\n");
2985 BTC_TRACE(trace_buf);
2986 halbtc8703b1ant_action_bt_whql_test(btcoexist);
2987 return;
2988 }
2989
2990 if (coex_sta->bt_disabled) {
2991 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2992 "[BTCoex], BT is disabled !!!\n");
2993 halbtc8703b1ant_action_wifi_only(btcoexist);
2994 return;
2995 }
2996
2997 if (coex_sta->c2h_bt_inquiry_page) {
2998 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2999 "[BTCoex], BT is under inquiry/page scan !!\n");
3000 BTC_TRACE(trace_buf);
3001 halbtc8703b1ant_action_bt_inquiry(btcoexist);
3002 return;
3003 }
3004
3005 if ((coex_sta->is_setupLink) &&
3006 (coex_sta->bt_relink_downcount != 0)) {
3007 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3008 "[BTCoex], BT is re-link !!!\n");
3009 halbtc8703b1ant_action_bt_relink(btcoexist);
3010 return;
3011 }
3012
3013 if ((BT_8703B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3014 (BT_8703B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3015 (BT_8703B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
3016 increase_scan_dev_num = TRUE;
3017
3018 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
3019 &increase_scan_dev_num);
3020
3021 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3022 &wifi_link_status);
3023
3024 num_of_wifi_link = wifi_link_status >> 16;
3025
3026 if ((num_of_wifi_link >= 2) ||
3027 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3028 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3029 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3030 num_of_wifi_link, wifi_link_status);
3031 BTC_TRACE(trace_buf);
3032
3033 if (bt_link_info->bt_link_exist)
3034 miracast_plus_bt = TRUE;
3035 else
3036 miracast_plus_bt = FALSE;
3037
3038 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3039 &miracast_plus_bt);
3040
3041 halbtc8703b1ant_action_wifi_multi_port(btcoexist);
3042
3043 return;
3044 }
3045
3046 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3047 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
3048
3049 if ((bt_link_info->bt_link_exist) && (wifi_connected)) {
3050
3051 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
3052
3053 if (BTC_IOT_PEER_CISCO == iot_peer) {
3054
3055 if (BTC_WIFI_BW_HT40 == wifi_bw)
3056 halbtc8703b1ant_limited_rx(btcoexist,
3057 NORMAL_EXEC, FALSE, TRUE, 0x10);
3058 else
3059 halbtc8703b1ant_limited_rx(btcoexist,
3060 NORMAL_EXEC, FALSE, TRUE, 0x8);
3061 }
3062 }
3063
3064 halbtc8703b1ant_run_sw_coexist_mechanism(
3065 btcoexist); /* just print debug message */
3066
3067 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3068
3069 if (bt_hs_on) {
3070 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3071 "############# [BTCoex], BT Is hs\n");
3072 BTC_TRACE(trace_buf);
3073 halbtc8703b1ant_action_bt_hs(btcoexist);
3074 return;
3075 }
3076
3077 if ((BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3078 coex_dm->bt_status) ||
3079 (BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE ==
3080 coex_dm->bt_status)) {
3081 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3082 "############# [BTCoex], BT Is idle\n");
3083 BTC_TRACE(trace_buf);
3084 halbtc8703b1ant_action_bt_idle(btcoexist);
3085 return;
3086 }
3087
3088 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3089 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3090 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3091 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3092 &under_4way);
3093
3094 if (scan || link || roam || under_4way) {
3095 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3096 "[BTCoex], scan = %d, link = %d, roam = %d 4way = %d!!!\n",
3097 scan, link, roam, under_4way);
3098 BTC_TRACE(trace_buf);
3099
3100 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3101 "[BTCoex], wifi is under linkscan process!!\n");
3102 BTC_TRACE(trace_buf);
3103
3104 halbtc8703b1ant_action_wifi_linkscan_process(btcoexist);
3105 } else if (wifi_connected) {
3106 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3107 "[BTCoex], wifi is under connected!!\n");
3108 BTC_TRACE(trace_buf);
3109
3110 halbtc8703b1ant_action_wifi_connected(btcoexist);
3111 } else {
3112 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3113 "[BTCoex], wifi is under not-connected!!\n");
3114 BTC_TRACE(trace_buf);
3115
3116 halbtc8703b1ant_action_wifi_not_connected(btcoexist);
3117 }
3118 }
3119
3120
halbtc8703b1ant_init_coex_dm(IN struct btc_coexist * btcoexist)3121 void halbtc8703b1ant_init_coex_dm(IN struct btc_coexist *btcoexist)
3122 {
3123 /* force to reset coex mechanism */
3124
3125 halbtc8703b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, FALSE);
3126
3127 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3128 "[BTCoex], Coex Mechanism Init!!\n");
3129 BTC_TRACE(trace_buf);
3130
3131 coex_sta->pop_event_cnt = 0;
3132 coex_sta->cnt_RemoteNameReq = 0;
3133 coex_sta->cnt_ReInit = 0;
3134 coex_sta->cnt_setupLink = 0;
3135 coex_sta->cnt_IgnWlanAct = 0;
3136 coex_sta->cnt_Page = 0;
3137 coex_sta->cnt_RoleSwitch = 0;
3138 }
3139
halbtc8703b1ant_init_hw_config(IN struct btc_coexist * btcoexist,IN boolean back_up,IN boolean wifi_only)3140 void halbtc8703b1ant_init_hw_config(IN struct btc_coexist *btcoexist,
3141 IN boolean back_up, IN boolean wifi_only)
3142 {
3143 u32 u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
3144 u8 i = 0;
3145
3146 u32tmp0 = btcoexist->btc_read_4byte(btcoexist, 0x70),
3147 u32tmp1 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
3148 u32tmp2 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
3149
3150 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3151 "\n [BTCoex], ********** 0x70/ 0x38/ 0x54 (Before Init HW config) = 0x%x/ 0x%x/ 0x%x**********\n",
3152 u32tmp0,
3153 u32tmp1, u32tmp2);
3154 BTC_TRACE(trace_buf);
3155
3156 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3157 "[BTCoex], 1Ant Init HW Config!!\n");
3158 BTC_TRACE(trace_buf);
3159
3160 coex_sta->bt_coex_supported_feature = 0;
3161 coex_sta->bt_coex_supported_version = 0;
3162 coex_sta->bt_ble_scan_type = 0;
3163 coex_sta->bt_ble_scan_para[0] = 0;
3164 coex_sta->bt_ble_scan_para[1] = 0;
3165 coex_sta->bt_ble_scan_para[2] = 0;
3166 coex_sta->gnt_error_cnt = 0;
3167 coex_sta->bt_relink_downcount = 0;
3168 coex_sta->wl_rx_rate = BTC_UNKNOWN;
3169
3170 for (i = 0; i <= 9; i++)
3171 coex_sta->bt_afh_map[i] = 0;
3172
3173 /* 0xf0[15:12] --> Chip Cut information */
3174 coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
3175 0xf1) & 0xf0) >> 4;
3176
3177 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
3178 0x1); /* enable TBTT nterrupt */
3179
3180 /* BT report packet sample rate */
3181 btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
3182
3183 /* Enable BT counter statistics */
3184 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
3185
3186 /* Enable PTA (3-wire function form BT side) */
3187 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3188 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x41, 0x02, 0x1);
3189
3190 /* Enable PTA (tx/rx signal form WiFi side) */
3191 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4c6, 0x10, 0x1);
3192
3193 halbtc8703b1ant_enable_gnt_to_gpio(btcoexist, FALSE);
3194
3195 #if 0
3196 if (btcoexist->btc_read_1byte(btcoexist, 0x80) == 0xc6)
3197 halbtc8703b1ant_post_state_to_bt(btcoexist,
3198 BT_8703B_1ANT_SCOREBOARD_ONOFF, TRUE);
3199 #endif
3200
3201 /* Antenna config */
3202 if (coex_sta->is_rf_state_off) {
3203
3204 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3205 FORCE_EXEC,
3206 BT_8703B_1ANT_PHASE_WLAN_OFF);
3207
3208 btcoexist->stop_coex_dm = TRUE;
3209
3210 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3211 "[BTCoex], ********** halbtc8703b1ant_init_hw_config (RF Off)**********\n");
3212 BTC_TRACE(trace_buf);
3213 } else if (wifi_only) {
3214 coex_sta->concurrent_rx_mode_on = FALSE;
3215 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
3216 FORCE_EXEC,
3217 BT_8703B_1ANT_PHASE_WLANONLY_INIT);
3218 } else {
3219 coex_sta->concurrent_rx_mode_on = TRUE;
3220 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x2, 0x1);
3221 /* RF 0x1[0] = 0->Set GNT_WL_RF_Rx always = 1 for con-current Rx */
3222 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0x1, 0x0);
3223 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3224 FORCE_EXEC,
3225 BT_8703B_1ANT_PHASE_COEX_INIT);
3226 }
3227
3228 /* PTA parameter */
3229 halbtc8703b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3230 halbtc8703b1ant_ps_tdma(btcoexist, FORCE_EXEC, FALSE, 8);
3231
3232 u32tmp0 = btcoexist->btc_read_4byte(btcoexist, 0x70),
3233 u32tmp1 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
3234 u32tmp2 = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
3235
3236 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3237 "[BTCoex], ********** 0x70/ 0x38/ 0x54 (After Init HW config) = 0x%x/ 0x%x/ 0x%x**********\n",
3238 u32tmp0,
3239 u32tmp1, u32tmp2);
3240 BTC_TRACE(trace_buf);
3241
3242 }
3243
3244
3245
3246 /* ************************************************************
3247 * work around function start with wa_halbtc8703b1ant_
3248 * ************************************************************
3249 * ************************************************************
3250 * extern function start with ex_halbtc8703b1ant_
3251 * ************************************************************ */
ex_halbtc8703b1ant_power_on_setting(IN struct btc_coexist * btcoexist)3252 void ex_halbtc8703b1ant_power_on_setting(IN struct btc_coexist *btcoexist)
3253 {
3254 struct btc_board_info *board_info = &btcoexist->board_info;
3255 u8 u8tmp = 0x0;
3256 u16 u16tmp = 0x0;
3257
3258 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3259 "xxxxxxxxxxxxxxxx Execute 8703b 1-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
3260 BTC_TRACE(trace_buf);
3261
3262 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3263 "Ant Det Finish = %s, Ant Det Number = %d\n",
3264 (board_info->btdm_ant_det_finish ? "Yes" : "No"),
3265 board_info->btdm_ant_num_by_ant_det);
3266 BTC_TRACE(trace_buf);
3267
3268 btcoexist->stop_coex_dm = TRUE;
3269 coex_sta->is_rf_state_off = FALSE;
3270
3271 /* enable BB, REG_SYS_FUNC_EN such that we can write BB/MAC reg correctly. */
3272 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
3273 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
3274
3275 /* set Path control owner to WiFi */
3276 halbtc8703b1ant_ltecoex_pathcontrol_owner(btcoexist,
3277 BT_8703B_1ANT_PCO_WLSIDE);
3278
3279 /* set GNT_BT to high */
3280 halbtc8703b1ant_ltecoex_set_gnt_bt(btcoexist,
3281 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
3282 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
3283 BT_8703B_1ANT_SIG_STA_SET_TO_HIGH);
3284 /* Set GNT_WL to low */
3285 halbtc8703b1ant_ltecoex_set_gnt_wl(btcoexist,
3286 BT_8703B_1ANT_GNT_BLOCK_RFC_BB,
3287 BT_8703B_1ANT_GNT_TYPE_CTRL_BY_SW,
3288 BT_8703B_1ANT_SIG_STA_SET_TO_LOW);
3289
3290 /* set WLAN_ACT = 0 */
3291 /*btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);*/
3292
3293 halbtc8703b1ant_enable_gnt_to_gpio(btcoexist, FALSE);
3294
3295 /* */
3296 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
3297 /* Local setting bit define */
3298 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
3299 /* BIT1: "0" for internal switch; "1" for external switch */
3300 /* BIT2: "0" for one antenna; "1" for two antenna */
3301 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
3302
3303 u8tmp = 0;
3304 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3305
3306 if (btcoexist->chip_interface == BTC_INTF_USB)
3307 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3308 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3309 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60, u8tmp);
3310
3311
3312
3313 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3314 "[BTCoex], ********** 0x70(MAC)/0x38/0x54 (Power-On) =0x%x/ 0x%x/ 0x%x**********\n",
3315 btcoexist->btc_read_4byte(btcoexist, 0x70),
3316 halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38),
3317 halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54));
3318 BTC_TRACE(trace_buf);
3319
3320
3321 }
3322
ex_halbtc8703b1ant_pre_load_firmware(IN struct btc_coexist * btcoexist)3323 void ex_halbtc8703b1ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
3324 {
3325 }
3326
ex_halbtc8703b1ant_init_hw_config(IN struct btc_coexist * btcoexist,IN boolean wifi_only)3327 void ex_halbtc8703b1ant_init_hw_config(IN struct btc_coexist *btcoexist,
3328 IN boolean wifi_only)
3329 {
3330 halbtc8703b1ant_init_hw_config(btcoexist, TRUE, wifi_only);
3331 btcoexist->stop_coex_dm = FALSE;
3332 }
3333
ex_halbtc8703b1ant_init_coex_dm(IN struct btc_coexist * btcoexist)3334 void ex_halbtc8703b1ant_init_coex_dm(IN struct btc_coexist *btcoexist)
3335 {
3336 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3337 "[BTCoex], Coex Mechanism Init!!\n");
3338 BTC_TRACE(trace_buf);
3339
3340 halbtc8703b1ant_init_coex_dm(btcoexist);
3341 }
3342
ex_halbtc8703b1ant_display_coex_info(IN struct btc_coexist * btcoexist)3343 void ex_halbtc8703b1ant_display_coex_info(IN struct btc_coexist *btcoexist)
3344 {
3345 struct btc_board_info *board_info = &btcoexist->board_info;
3346 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3347 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3348 u8 *cli_buf = btcoexist->cli_buf;
3349 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3350 u16 u16tmp[4];
3351 u32 u32tmp[4];
3352 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck;
3353 u32 fw_ver = 0, bt_patch_ver = 0, bt_coex_ver = 0;
3354 static u8 pop_report_in_10s = 0, cnt = 0;
3355 u32 phyver = 0;
3356 boolean lte_coex_on = FALSE;
3357
3358 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3359 "\r\n ============[BT Coexist info]============");
3360 CL_PRINTF(cli_buf);
3361
3362 if (btcoexist->manual_control) {
3363 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3364 "\r\n ============[Under Manual Control]============");
3365 CL_PRINTF(cli_buf);
3366 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3367 "\r\n ==========================================");
3368 CL_PRINTF(cli_buf);
3369 }
3370 if (btcoexist->stop_coex_dm) {
3371 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3372 "\r\n ============[Coex is STOPPED]============");
3373 CL_PRINTF(cli_buf);
3374 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3375 "\r\n ==========================================");
3376 CL_PRINTF(cli_buf);
3377 }
3378
3379 if (!coex_sta->bt_disabled) {
3380 if (coex_sta->bt_coex_supported_feature == 0)
3381 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_FEATURE,
3382 &coex_sta->bt_coex_supported_feature);
3383
3384 if ((coex_sta->bt_coex_supported_version == 0) ||
3385 (coex_sta->bt_coex_supported_version == 0xffff))
3386 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_VERSION,
3387 &coex_sta->bt_coex_supported_version);
3388
3389 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3390 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
3391
3392 if (coex_sta->num_of_profile > 0) {
3393 cnt++;
3394
3395 if (cnt >= 3) {
3396 btcoexist->btc_get_bt_afh_map_from_bt(btcoexist, 0,
3397 &coex_sta->bt_afh_map[0]);
3398 cnt = 0;
3399 }
3400 }
3401 }
3402
3403 if (psd_scan->ant_det_try_count == 0) {
3404 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
3405 "Ant PG Num/ Mech/ Pos",
3406 board_info->pg_ant_num, board_info->btdm_ant_num,
3407 board_info->btdm_ant_pos);
3408 CL_PRINTF(cli_buf);
3409 } else {
3410 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3411 "\r\n %-35s = %d/ %d/ %d (%d/%d/%d)",
3412 "Ant PG Num/ Mech(Ant_Det)/ Pos",
3413 board_info->pg_ant_num,
3414 board_info->btdm_ant_num_by_ant_det,
3415 board_info->btdm_ant_pos,
3416 psd_scan->ant_det_try_count,
3417 psd_scan->ant_det_fail_count,
3418 psd_scan->ant_det_result);
3419 CL_PRINTF(cli_buf);
3420
3421 if (board_info->btdm_ant_det_finish) {
3422 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
3423 "Ant Det PSD Value",
3424 psd_scan->ant_det_peak_val);
3425 CL_PRINTF(cli_buf);
3426 }
3427 }
3428
3429
3430 /*bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;*/
3431 bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
3432 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3433 phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
3434
3435 bt_coex_ver = ((coex_sta->bt_coex_supported_version & 0xff00) >> 8);
3436
3437 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3438 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
3439 "CoexVer WL/ BT_Desired/ BT_Report",
3440 glcoex_ver_date_8703b_1ant, glcoex_ver_8703b_1ant,
3441 glcoex_ver_btdesired_8703b_1ant,
3442 bt_coex_ver,
3443 (bt_coex_ver == 0xff ? "Unknown" :
3444 (bt_coex_ver >= glcoex_ver_btdesired_8703b_1ant ?
3445 "Match":"Mis-Match")));
3446 CL_PRINTF(cli_buf);
3447
3448 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3449 "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
3450 "W_FW/ B_FW/ Phy/ Kt",
3451 fw_ver, bt_patch_ver, phyver,
3452 coex_sta->cut_version + 65);
3453 CL_PRINTF(cli_buf);
3454
3455 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
3456 "Wifi channel informed to BT",
3457 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
3458 coex_dm->wifi_chnl_info[2]);
3459 CL_PRINTF(cli_buf);
3460 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s",
3461 "WifibHiPri/ Ccklock/ CckEverLock",
3462 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
3463 (coex_sta->cck_lock ? "Yes" : "No"),
3464 (coex_sta->cck_lock_ever ? "Yes" : "No"));
3465 CL_PRINTF(cli_buf);
3466
3467 /* wifi status */
3468 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3469 "============[Wifi Status]============");
3470 CL_PRINTF(cli_buf);
3471 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
3472
3473 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3474 "============[BT Status]============");
3475 CL_PRINTF(cli_buf);
3476
3477 pop_report_in_10s++;
3478 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %ddBm/ %d/ %d",
3479 "BT status/ rssi/ retryCnt/ popCnt",
3480 ((coex_sta->bt_disabled) ? ("disabled") : ((
3481 coex_sta->c2h_bt_inquiry_page) ? ("inquiry-page")
3482 : ((BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3483 coex_dm->bt_status) ? "non-connected-idle" :
3484 ((BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
3485 ? "connected-idle" : "busy")))),
3486 coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
3487 coex_sta->pop_event_cnt);
3488 CL_PRINTF(cli_buf);
3489
3490 if (pop_report_in_10s >= 5) {
3491 coex_sta->pop_event_cnt = 0;
3492 pop_report_in_10s = 0;
3493 }
3494
3495 if (coex_sta->num_of_profile != 0)
3496 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3497 "\r\n %-35s = %s%s%s%s%s",
3498 "Profiles",
3499 ((bt_link_info->a2dp_exist) ?
3500 ((coex_sta->is_bt_a2dp_sink) ? "A2DP sink," :
3501 "A2DP,") : ""),
3502 ((bt_link_info->sco_exist) ? "HFP," : ""),
3503 ((bt_link_info->hid_exist) ?
3504 ((coex_sta->is_hid_rcu) ? "HID(RCU)" :
3505 ((coex_sta->hid_busy_num >= 2) ? "HID(4/18)," :
3506 "HID(2/18),")) : ""),
3507 ((bt_link_info->pan_exist) ?
3508 ((coex_sta->is_bt_opp_exist) ? "OPP," : "PAN,") : ""),
3509 ((coex_sta->voice_over_HOGP) ? "Voice" : ""));
3510 else
3511 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3512 "\r\n %-35s = None", "Profiles");
3513
3514 CL_PRINTF(cli_buf);
3515
3516 if (bt_link_info->a2dp_exist) {
3517 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s",
3518 "A2DP Rate/Bitpool/Auto_Slot",
3519 ((coex_sta->is_A2DP_3M) ? "3M" : "No_3M"),
3520 coex_sta->a2dp_bit_pool,
3521 ((coex_sta->is_autoslot) ? "On" : "Off")
3522 );
3523 CL_PRINTF(cli_buf);
3524
3525 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ %d/ %d",
3526 "V_ID/D_name/FBSlot_Legacy/FBSlot_Le",
3527 coex_sta->bt_a2dp_vendor_id,
3528 coex_sta->bt_a2dp_device_name,
3529 coex_sta->legacy_forbidden_slot,
3530 coex_sta->le_forbidden_slot
3531 );
3532 CL_PRINTF(cli_buf);
3533 }
3534
3535 if (bt_link_info->hid_exist) {
3536 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
3537 "HID PairNum",
3538 coex_sta->hid_pair_cnt
3539 );
3540 CL_PRINTF(cli_buf);
3541 }
3542
3543 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s/ 0x%x",
3544 "Role/RoleSwCnt/IgnWlact/Feature",
3545 ((bt_link_info->slave_role) ? "Slave" : "Master"),
3546 coex_sta->cnt_RoleSwitch,
3547 ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
3548 coex_sta->bt_coex_supported_feature);
3549 CL_PRINTF(cli_buf);
3550
3551
3552 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
3553 "ReInit/ReLink/IgnWlact/Page/NameReq",
3554 coex_sta->cnt_ReInit,
3555 coex_sta->cnt_setupLink,
3556 coex_sta->cnt_IgnWlanAct,
3557 coex_sta->cnt_Page,
3558 coex_sta->cnt_RemoteNameReq
3559 );
3560 CL_PRINTF(cli_buf);
3561
3562 halbtc8703b1ant_read_score_board(btcoexist, &u16tmp[0]);
3563
3564 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%04x",
3565 "ScoreBoard(B->W)", u16tmp[0]);
3566 CL_PRINTF(cli_buf);
3567
3568 if (coex_sta->num_of_profile > 0) {
3569
3570 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3571 "\r\n %-35s = %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x",
3572 "AFH MAP",
3573 coex_sta->bt_afh_map[0],
3574 coex_sta->bt_afh_map[1],
3575 coex_sta->bt_afh_map[2],
3576 coex_sta->bt_afh_map[3],
3577 coex_sta->bt_afh_map[4],
3578 coex_sta->bt_afh_map[5],
3579 coex_sta->bt_afh_map[6],
3580 coex_sta->bt_afh_map[7],
3581 coex_sta->bt_afh_map[8],
3582 coex_sta->bt_afh_map[9]
3583 );
3584 CL_PRINTF(cli_buf);
3585 }
3586
3587 for (i = 0; i < BT_INFO_SRC_8703B_1ANT_MAX; i++) {
3588 if (coex_sta->bt_info_c2h_cnt[i]) {
3589 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3590 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x (%d)",
3591 glbt_info_src_8703b_1ant[i],
3592 coex_sta->bt_info_c2h[i][0],
3593 coex_sta->bt_info_c2h[i][1],
3594 coex_sta->bt_info_c2h[i][2],
3595 coex_sta->bt_info_c2h[i][3],
3596 coex_sta->bt_info_c2h[i][4],
3597 coex_sta->bt_info_c2h[i][5],
3598 coex_sta->bt_info_c2h[i][6],
3599 coex_sta->bt_info_c2h_cnt[i]);
3600 CL_PRINTF(cli_buf);
3601 }
3602 }
3603
3604 if (btcoexist->manual_control)
3605 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3606 "============[mechanisms] (before Manual)============");
3607 else
3608 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3609 "============[mechanisms]============");
3610 CL_PRINTF(cli_buf);
3611
3612 ps_tdma_case = coex_dm->cur_ps_tdma;
3613 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3614 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (%s)",
3615 "PS TDMA",
3616 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
3617 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
3618 coex_dm->ps_tdma_para[4], ps_tdma_case,
3619 (coex_dm->cur_ps_tdma_on ? "TDMA On" : "TDMA Off"));
3620
3621 CL_PRINTF(cli_buf);
3622
3623 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3624 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3625 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3626 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3627 "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
3628 "Table/0x6c0/0x6c4/0x6c8",
3629 coex_sta->coex_table_type, u32tmp[0], u32tmp[1], u32tmp[2]);
3630 CL_PRINTF(cli_buf);
3631
3632 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3633 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
3634 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3635 "\r\n %-35s = 0x%x/ 0x%x/ 0x%04x",
3636 "0x778/0x6cc/Scoreboard(W->B)",
3637 u8tmp[0], u32tmp[0], coex_sta->score_board_WB);
3638 CL_PRINTF(cli_buf);
3639
3640 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
3641 "BtCtrlLPS/LPRA",
3642 ((coex_sta->force_lps_ctrl) ? "On" : "Off"),
3643 ((coex_dm->cur_low_penalty_ra) ? "On" : "Off"));
3644 CL_PRINTF(cli_buf);
3645
3646 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
3647 "BT_Empty/BT_Late",
3648 coex_sta->wl_fw_dbg_info[4],
3649 coex_sta->wl_fw_dbg_info[5]);
3650 CL_PRINTF(cli_buf);
3651
3652 u32tmp[0] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
3653 lte_coex_on = ((u32tmp[0] & BIT(7)) >> 7) ? TRUE : FALSE;
3654
3655 if (lte_coex_on) {
3656 u32tmp[0] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
3657 0xa0);
3658 u32tmp[1] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
3659 0xa4);
3660
3661 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
3662 "LTE Coex Table W_L/B_L",
3663 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff);
3664 CL_PRINTF(cli_buf);
3665
3666 u32tmp[0] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
3667 0xa8);
3668 u32tmp[1] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
3669 0xac);
3670 u32tmp[2] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
3671 0xb0);
3672 u32tmp[3] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist,
3673 0xb4);
3674
3675 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3676 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3677 "LTE Break Table W_L/B_L/L_W/L_B",
3678 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff,
3679 u32tmp[2] & 0xffff, u32tmp[3] & 0xffff);
3680 CL_PRINTF(cli_buf);
3681 }
3682 /* Hw setting */
3683 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3684 "============[Hw setting]============");
3685 CL_PRINTF(cli_buf);
3686
3687 u32tmp[0] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
3688 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x73);
3689
3690 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %s",
3691 "LTE CoexOn/Path Ctrl Owner",
3692 (int)((u32tmp[0] & BIT(7)) >> 7),
3693 ((u8tmp[0] & BIT(2)) ? "WL" : "BT"));
3694 CL_PRINTF(cli_buf);
3695
3696 if (lte_coex_on) {
3697 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
3698 "LTE 3Wire/OPMode/UART/UARTMode",
3699 (int)((u32tmp[0] & BIT(6)) >> 6),
3700 (int)((u32tmp[0] & (BIT(5) | BIT(4))) >> 4),
3701 (int)((u32tmp[0] & BIT(3)) >> 3),
3702 (int)(u32tmp[0] & (BIT(2) | BIT(1) | BIT(0))));
3703 CL_PRINTF(cli_buf);
3704 }
3705 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3706 "\r\n %-35s = %s (BB:%s)/ %s (BB:%s)/ %s (gnt_err = %d)",
3707 "GNT_WL_Ctrl/GNT_BT_Ctrl/Dbg",
3708 ((u32tmp[0] & BIT(12)) ? "SW" : "HW"),
3709 ((u32tmp[0] & BIT(8)) ? "SW" : "HW"),
3710 ((u32tmp[0] & BIT(14)) ? "SW" : "HW"),
3711 ((u32tmp[0] & BIT(10)) ? "SW" : "HW"),
3712 ((u8tmp[0] & BIT(3)) ? "On" : "Off"),
3713 coex_sta->gnt_error_cnt);
3714 CL_PRINTF(cli_buf);
3715
3716 u32tmp[0] = halbtc8703b1ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
3717
3718 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
3719 "GNT_WL/GNT_BT/LTE_Busy/UART_Busy",
3720 (int)((u32tmp[0] & BIT(2)) >> 2),
3721 (int)((u32tmp[0] & BIT(3)) >> 3),
3722 (int)((u32tmp[0] & BIT(1)) >> 1), (int)(u32tmp[0] & BIT(0)));
3723 CL_PRINTF(cli_buf);
3724
3725
3726 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x4c6);
3727 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3728
3729 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
3730 "0x4c6[4]/0x40[5] (WL/BT PTA)",
3731 (int)((u8tmp[0] & BIT(4)) >> 4),
3732 (int)((u8tmp[1] & BIT(5)) >> 5));
3733 CL_PRINTF(cli_buf);
3734
3735 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3736 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3737 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x953);
3738 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ %s",
3739 "0x550(bcn ctrl)/0x522/4-RxAGC",
3740 u32tmp[0], u8tmp[0], (u8tmp[1] & 0x2) ? "On" : "Off");
3741 CL_PRINTF(cli_buf);
3742
3743 fa_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_OFDM);
3744 fa_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_CCK);
3745 cca_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_OFDM);
3746 cca_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_CCK);
3747
3748 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3749 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3750 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA",
3751 cca_cck, fa_cck, cca_ofdm, fa_ofdm);
3752 CL_PRINTF(cli_buf);
3753
3754 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d (Rx_rate Data/RTS= %d/%d)",
3755 "CRC_OK CCK/11g/11n/11ac",
3756 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
3757 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht,
3758 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate);
3759 CL_PRINTF(cli_buf);
3760
3761 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
3762 "CRC_Err CCK/11g/11n/11n-agg",
3763 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
3764 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
3765 CL_PRINTF(cli_buf);
3766
3767 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d",
3768 "WlHiPri/ Locking/ Locked/ Noisy",
3769 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
3770 (coex_sta->cck_lock ? "Yes" : "No"),
3771 (coex_sta->cck_lock_ever ? "Yes" : "No"),
3772 coex_sta->wl_noisy_level);
3773 CL_PRINTF(cli_buf);
3774
3775 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
3776 "0x770(Hi-pri rx/tx)",
3777 coex_sta->high_priority_rx, coex_sta->high_priority_tx,
3778 (coex_sta->is_hiPri_rx_overhead ? "(scan overhead!!)" : ""));
3779 CL_PRINTF(cli_buf);
3780
3781 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
3782 "0x774(Lo-pri rx/tx)",
3783 coex_sta->low_priority_rx, coex_sta->low_priority_tx,
3784 (bt_link_info->slave_role ? "(Slave!!)" : (
3785 coex_sta->is_tdma_btautoslot_hang ? "(auto-slot hang!!)" : "")));
3786 CL_PRINTF(cli_buf);
3787
3788 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
3789 }
3790
3791
ex_halbtc8703b1ant_ips_notify(IN struct btc_coexist * btcoexist,IN u8 type)3792 void ex_halbtc8703b1ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
3793 {
3794 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
3795 return;
3796
3797 if (BTC_IPS_ENTER == type) {
3798 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3799 "[BTCoex], IPS ENTER notify\n");
3800 BTC_TRACE(trace_buf);
3801 coex_sta->under_ips = TRUE;
3802 coex_sta->under_lps = FALSE;
3803
3804 /* Write WL "Active" in Score-board for LPS off */
3805 halbtc8703b1ant_post_state_to_bt(btcoexist,
3806 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
3807 BT_8703B_1ANT_SCOREBOARD_ONOFF |
3808 BT_8703B_1ANT_SCOREBOARD_SCAN |
3809 BT_8703B_1ANT_SCOREBOARD_UNDERTEST,
3810 FALSE);
3811
3812 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3813 FORCE_EXEC,
3814 BT_8703B_1ANT_PHASE_WLAN_OFF);
3815
3816 halbtc8703b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3817 halbtc8703b1ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 0);
3818 } else if (BTC_IPS_LEAVE == type) {
3819 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3820 "[BTCoex], IPS LEAVE notify\n");
3821 BTC_TRACE(trace_buf);
3822 #if 0
3823 halbtc8703b1ant_post_state_to_bt(btcoexist,
3824 BT_8703B_1ANT_SCOREBOARD_ACTIVE, TRUE);
3825 #endif
3826 halbtc8703b1ant_init_hw_config(btcoexist, FALSE, FALSE);
3827 halbtc8703b1ant_init_coex_dm(btcoexist);
3828 halbtc8703b1ant_query_bt_info(btcoexist);
3829
3830 coex_sta->under_ips = FALSE;
3831 }
3832 }
3833
ex_halbtc8703b1ant_lps_notify(IN struct btc_coexist * btcoexist,IN u8 type)3834 void ex_halbtc8703b1ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
3835 {
3836 static boolean pre_force_lps_on = FALSE;
3837
3838 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
3839 return;
3840
3841 if (BTC_LPS_ENABLE == type) {
3842 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3843 "[BTCoex], LPS ENABLE notify\n");
3844 BTC_TRACE(trace_buf);
3845 coex_sta->under_lps = TRUE;
3846 coex_sta->under_ips = FALSE;
3847
3848 if (coex_sta->force_lps_ctrl == TRUE) { /* LPS No-32K */
3849 /* Write WL "Active" in Score-board for PS-TDMA */
3850 pre_force_lps_on = TRUE;
3851 halbtc8703b1ant_post_state_to_bt(btcoexist,
3852 BT_8703B_1ANT_SCOREBOARD_ACTIVE, TRUE);
3853
3854 } else { /* LPS-32K, need check if this h2c 0x71 can work?? (2015/08/28) */
3855 /* Write WL "Non-Active" in Score-board for Native-PS */
3856 pre_force_lps_on = FALSE;
3857 halbtc8703b1ant_post_state_to_bt(btcoexist,
3858 BT_8703B_1ANT_SCOREBOARD_ACTIVE, FALSE);
3859
3860 halbtc8703b1ant_action_wifi_native_lps(btcoexist);
3861 }
3862 } else if (BTC_LPS_DISABLE == type) {
3863 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3864 "[BTCoex], LPS DISABLE notify\n");
3865 BTC_TRACE(trace_buf);
3866 coex_sta->under_lps = FALSE;
3867
3868 /* Write WL "Active" in Score-board for LPS off */
3869 halbtc8703b1ant_post_state_to_bt(btcoexist,
3870 BT_8703B_1ANT_SCOREBOARD_ACTIVE, TRUE);
3871
3872 if ((pre_force_lps_on == FALSE) && (!coex_sta->force_lps_ctrl))
3873 halbtc8703b1ant_query_bt_info(btcoexist);
3874 }
3875 }
3876
ex_halbtc8703b1ant_scan_notify(IN struct btc_coexist * btcoexist,IN u8 type)3877 void ex_halbtc8703b1ant_scan_notify(IN struct btc_coexist *btcoexist,
3878 IN u8 type)
3879 {
3880 boolean wifi_connected = FALSE;
3881
3882 if (btcoexist->manual_control ||
3883 btcoexist->stop_coex_dm)
3884 return;
3885
3886 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3887 &wifi_connected);
3888
3889
3890 if (BTC_SCAN_START == type) {
3891
3892 coex_sta->wifi_is_high_pri_task = TRUE;
3893
3894 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3895 "[BTCoex], SCAN START notify\n");
3896 BTC_TRACE(trace_buf);
3897
3898 halbtc8703b1ant_post_state_to_bt(btcoexist,
3899 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
3900 BT_8703B_1ANT_SCOREBOARD_SCAN |
3901 BT_8703B_1ANT_SCOREBOARD_ONOFF,
3902 TRUE);
3903
3904 halbtc8703b1ant_query_bt_info(btcoexist);
3905
3906 /* Force antenna setup for no scan result issue */
3907 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3908 FORCE_EXEC,
3909 BT_8703B_1ANT_PHASE_2G_RUNTIME);
3910
3911 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
3912
3913 } else {
3914
3915 coex_sta->wifi_is_high_pri_task = FALSE;
3916
3917 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3918 &coex_sta->scan_ap_num);
3919
3920 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3921 "[BTCoex], SCAN FINISH notify (Scan-AP = %d)\n",
3922 coex_sta->scan_ap_num);
3923 BTC_TRACE(trace_buf);
3924
3925 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
3926 }
3927
3928 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3929 "[BTCoex], SCAN START Notify() end\n");
3930 BTC_TRACE(trace_buf);
3931
3932 }
3933
ex_halbtc8703b1ant_connect_notify(IN struct btc_coexist * btcoexist,IN u8 type)3934 void ex_halbtc8703b1ant_connect_notify(IN struct btc_coexist *btcoexist,
3935 IN u8 type)
3936 {
3937 boolean wifi_connected = FALSE;
3938
3939 if (btcoexist->manual_control ||
3940 btcoexist->stop_coex_dm)
3941 return;
3942
3943 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3944 &wifi_connected);
3945
3946 if (BTC_ASSOCIATE_START == type) {
3947 coex_sta->wifi_is_high_pri_task = TRUE;
3948
3949 halbtc8703b1ant_post_state_to_bt(btcoexist,
3950 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
3951 BT_8703B_1ANT_SCOREBOARD_SCAN |
3952 BT_8703B_1ANT_SCOREBOARD_ONOFF,
3953 TRUE);
3954
3955 /* Force antenna setup for no scan result issue */
3956 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
3957 FORCE_EXEC,
3958 BT_8703B_1ANT_PHASE_2G_RUNTIME);
3959
3960 /* psd_scan->ant_det_is_ant_det_available = TRUE; */
3961 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3962 "[BTCoex], CONNECT START notify\n");
3963 BTC_TRACE(trace_buf);
3964 coex_dm->arp_cnt = 0;
3965
3966 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
3967 } else {
3968 coex_sta->wifi_is_high_pri_task = FALSE;
3969 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3970 "[BTCoex], CONNECT FINISH notify\n");
3971 BTC_TRACE(trace_buf);
3972
3973 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
3974 }
3975
3976 }
3977
ex_halbtc8703b1ant_media_status_notify(IN struct btc_coexist * btcoexist,IN u8 type)3978 void ex_halbtc8703b1ant_media_status_notify(IN struct btc_coexist *btcoexist,
3979 IN u8 type)
3980 {
3981 boolean wifi_under_b_mode = FALSE;
3982
3983 if (btcoexist->manual_control ||
3984 btcoexist->stop_coex_dm)
3985 return;
3986
3987 if (BTC_MEDIA_CONNECT == type) {
3988
3989 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3990 "[BTCoex], MEDIA connect notify\n");
3991 BTC_TRACE(trace_buf);
3992
3993 halbtc8703b1ant_post_state_to_bt(btcoexist,
3994 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
3995 BT_8703B_1ANT_SCOREBOARD_ONOFF,
3996 TRUE);
3997
3998 /* Force antenna setup for no scan result issue */
3999 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4000 FORCE_EXEC,
4001 BT_8703B_1ANT_PHASE_2G_RUNTIME);
4002
4003 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
4004 &wifi_under_b_mode);
4005
4006 /* Set CCK Tx/Rx high Pri except 11b mode */
4007 if (wifi_under_b_mode) {
4008 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
4009 0x00); /* CCK Tx */
4010 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
4011 0x00); /* CCK Rx */
4012 } else {
4013 /* btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x10); */ /*CCK Tx */
4014 /* btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x10); */ /*CCK Rx */
4015 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
4016 0x00); /* CCK Tx */
4017 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
4018 0x10); /* CCK Rx */
4019 }
4020
4021 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
4022 0x430);
4023 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
4024 0x434);
4025 coex_dm->backup_retry_limit = btcoexist->btc_read_2byte(
4026 btcoexist, 0x42a);
4027 coex_dm->backup_ampdu_max_time = btcoexist->btc_read_1byte(
4028 btcoexist, 0x456);
4029 } else {
4030
4031 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4032 "[BTCoex], MEDIA disconnect notify\n");
4033 BTC_TRACE(trace_buf);
4034
4035 halbtc8703b1ant_post_state_to_bt(btcoexist,
4036 BT_8703B_1ANT_SCOREBOARD_ACTIVE, FALSE);
4037
4038 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
4039 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
4040
4041 coex_sta->cck_lock_ever = FALSE;
4042 }
4043
4044 halbtc8703b1ant_update_wifi_channel_info(btcoexist, type);
4045
4046 }
4047
ex_halbtc8703b1ant_specific_packet_notify(IN struct btc_coexist * btcoexist,IN u8 type)4048 void ex_halbtc8703b1ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
4049 IN u8 type)
4050 {
4051 boolean under_4way = FALSE;
4052
4053 if (btcoexist->manual_control ||
4054 btcoexist->stop_coex_dm)
4055 return;
4056
4057
4058 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
4059 &under_4way);
4060
4061 if (under_4way) {
4062
4063 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4064 "[BTCoex], specific Packet ---- under_4way!!\n");
4065 BTC_TRACE(trace_buf);
4066
4067 coex_sta->wifi_is_high_pri_task = TRUE;
4068 coex_sta->specific_pkt_period_cnt = 2;
4069 } else if (BTC_PACKET_ARP == type) {
4070
4071 coex_dm->arp_cnt++;
4072 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4073 "[BTCoex], specific Packet ARP notify -cnt = %d\n",
4074 coex_dm->arp_cnt);
4075 BTC_TRACE(trace_buf);
4076
4077 } else {
4078
4079 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4080 "[BTCoex], specific Packet DHCP or EAPOL notify [Type = %d]\n",
4081 type);
4082 BTC_TRACE(trace_buf);
4083
4084 coex_sta->wifi_is_high_pri_task = TRUE;
4085 coex_sta->specific_pkt_period_cnt = 2;
4086 }
4087
4088 if (coex_sta->wifi_is_high_pri_task) {
4089 halbtc8703b1ant_post_state_to_bt(btcoexist,
4090 BT_8703B_1ANT_SCOREBOARD_SCAN, TRUE);
4091 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
4092 }
4093 }
4094
ex_halbtc8703b1ant_bt_info_notify(IN struct btc_coexist * btcoexist,IN u8 * tmp_buf,IN u8 length)4095 void ex_halbtc8703b1ant_bt_info_notify(IN struct btc_coexist *btcoexist,
4096 IN u8 *tmp_buf, IN u8 length)
4097 {
4098 u8 i, rsp_source = 0;
4099 boolean wifi_connected = FALSE;
4100 boolean wifi_scan = FALSE, wifi_link = FALSE, wifi_roam = FALSE,
4101 wifi_busy = FALSE;
4102 static boolean is_scoreboard_scan = FALSE;
4103
4104
4105 rsp_source = tmp_buf[0] & 0xf;
4106 if (rsp_source >= BT_INFO_SRC_8703B_1ANT_MAX)
4107 rsp_source = BT_INFO_SRC_8703B_1ANT_WIFI_FW;
4108 coex_sta->bt_info_c2h_cnt[rsp_source]++;
4109
4110 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4111 "[BTCoex], Bt_info[%d], len=%d, data=[", rsp_source,
4112 length);
4113 BTC_TRACE(trace_buf);
4114
4115 for (i = 0; i < length; i++) {
4116 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
4117
4118 if (i == length - 1) {
4119 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
4120 tmp_buf[i]);
4121 BTC_TRACE(trace_buf);
4122 } else {
4123 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
4124 tmp_buf[i]);
4125 BTC_TRACE(trace_buf);
4126 }
4127 }
4128
4129 coex_sta->bt_info = coex_sta->bt_info_c2h[rsp_source][1];
4130 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4131 coex_sta->bt_info_ext2 = coex_sta->bt_info_c2h[rsp_source][5];
4132
4133 if (BT_INFO_SRC_8703B_1ANT_WIFI_FW != rsp_source) {
4134
4135 /* if 0xff, it means BT is under WHCK test */
4136 coex_sta->bt_whck_test = ((coex_sta->bt_info == 0xff) ? TRUE :
4137 FALSE);
4138
4139 coex_sta->bt_create_connection = ((
4140 coex_sta->bt_info_c2h[rsp_source][2] & 0x80) ? TRUE :
4141 FALSE);
4142
4143 /* unit: %, value-100 to translate to unit: dBm */
4144 coex_sta->bt_rssi = coex_sta->bt_info_c2h[rsp_source][3] * 2 +
4145 10;
4146
4147 coex_sta->c2h_bt_remote_name_req = ((
4148 coex_sta->bt_info_c2h[rsp_source][2] & 0x20) ? TRUE :
4149 FALSE);
4150
4151 coex_sta->is_A2DP_3M = ((coex_sta->bt_info_c2h[rsp_source][2] &
4152 0x10) ? TRUE : FALSE);
4153
4154 coex_sta->acl_busy = ((coex_sta->bt_info_c2h[rsp_source][1] &
4155 0x8) ? TRUE : FALSE);
4156
4157 coex_sta->voice_over_HOGP = ((coex_sta->bt_info_ext & 0x10) ?
4158 TRUE : FALSE);
4159
4160 coex_sta->c2h_bt_inquiry_page = ((coex_sta->bt_info &
4161 BT_INFO_8703B_1ANT_B_INQ_PAGE) ? TRUE : FALSE);
4162
4163 coex_sta->a2dp_bit_pool = (((
4164 coex_sta->bt_info_c2h[rsp_source][1] & 0x49) == 0x49) ?
4165 coex_sta->bt_info_c2h[rsp_source][6] : 0);
4166
4167 coex_sta->is_bt_a2dp_sink = (coex_sta->bt_info_c2h[rsp_source][6] & 0x80) ?
4168 TRUE : FALSE;
4169
4170 coex_sta->bt_retry_cnt = coex_sta->bt_info_c2h[rsp_source][2] &
4171 0xf;
4172
4173 coex_sta->is_autoslot = coex_sta->bt_info_ext2 & 0x8;
4174
4175 coex_sta->forbidden_slot = coex_sta->bt_info_ext2 & 0x7;
4176
4177 coex_sta->hid_busy_num = (coex_sta->bt_info_ext2 & 0x30) >> 4;
4178
4179 coex_sta->hid_pair_cnt = (coex_sta->bt_info_ext2 & 0xc0) >> 6;
4180
4181 coex_sta->is_bt_opp_exist = (coex_sta->bt_info_ext2 & 0x1) ? TRUE : FALSE;
4182
4183 if (coex_sta->bt_retry_cnt >= 1)
4184 coex_sta->pop_event_cnt++;
4185
4186 if (coex_sta->c2h_bt_remote_name_req)
4187 coex_sta->cnt_RemoteNameReq++;
4188
4189 if (coex_sta->bt_info_ext & BIT(1))
4190 coex_sta->cnt_ReInit++;
4191
4192 if (coex_sta->bt_info_ext & BIT(2)) {
4193 coex_sta->cnt_setupLink++;
4194 coex_sta->is_setupLink = TRUE;
4195 coex_sta->bt_relink_downcount = 2;
4196 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4197 "[BTCoex], Re-Link start in BT info!!\n");
4198 BTC_TRACE(trace_buf);
4199 } else {
4200 coex_sta->is_setupLink = FALSE;
4201 coex_sta->bt_relink_downcount = 0;
4202 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4203 "[BTCoex], Re-Link stop in BT info!!\n");
4204 BTC_TRACE(trace_buf);
4205 }
4206
4207 if (coex_sta->bt_info_ext & BIT(3))
4208 coex_sta->cnt_IgnWlanAct++;
4209
4210 if (coex_sta->bt_info_ext & BIT(6))
4211 coex_sta->cnt_RoleSwitch++;
4212
4213 if (coex_sta->bt_info_ext & BIT(7))
4214 coex_sta->is_bt_multi_link = TRUE;
4215 else
4216 coex_sta->is_bt_multi_link = FALSE;
4217
4218 if (coex_sta->bt_info_ext & BIT(0))
4219 coex_sta->is_hid_rcu = TRUE;
4220 else
4221 coex_sta->is_hid_rcu = FALSE;
4222
4223 if (coex_sta->bt_info_ext & BIT(5))
4224 coex_sta->is_ble_scan_toggle = TRUE;
4225 else
4226 coex_sta->is_ble_scan_toggle = FALSE;
4227
4228 if (coex_sta->bt_create_connection) {
4229 coex_sta->cnt_Page++;
4230
4231 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
4232 &wifi_busy);
4233
4234 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
4235 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
4236 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
4237
4238 if ((wifi_link) || (wifi_roam) || (wifi_scan) ||
4239 (coex_sta->wifi_is_high_pri_task) || (wifi_busy)) {
4240
4241 is_scoreboard_scan = TRUE;
4242 halbtc8703b1ant_post_state_to_bt(btcoexist,
4243 BT_8703B_1ANT_SCOREBOARD_SCAN, TRUE);
4244
4245 } else
4246 halbtc8703b1ant_post_state_to_bt(btcoexist,
4247 BT_8703B_1ANT_SCOREBOARD_SCAN, FALSE);
4248
4249 } else {
4250 if (is_scoreboard_scan) {
4251 halbtc8703b1ant_post_state_to_bt(btcoexist,
4252 BT_8703B_1ANT_SCOREBOARD_SCAN, FALSE);
4253 is_scoreboard_scan = FALSE;
4254 }
4255 }
4256
4257 /* Here we need to resend some wifi info to BT */
4258 /* because bt is reset and loss of the info. */
4259
4260 if ((!btcoexist->manual_control) &&
4261 (!btcoexist->stop_coex_dm)) {
4262
4263 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4264 &wifi_connected);
4265
4266 /* Re-Init */
4267 if ((coex_sta->bt_info_ext & BIT(1))) {
4268 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4269 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
4270 BTC_TRACE(trace_buf);
4271 if (wifi_connected)
4272 halbtc8703b1ant_update_wifi_channel_info(
4273 btcoexist, BTC_MEDIA_CONNECT);
4274 else
4275 halbtc8703b1ant_update_wifi_channel_info(
4276 btcoexist,
4277 BTC_MEDIA_DISCONNECT);
4278 }
4279
4280
4281 /* If Ignore_WLanAct && not SetUp_Link */
4282 if ((coex_sta->bt_info_ext & BIT(3)) &&
4283 (!(coex_sta->bt_info_ext & BIT(2)))) {
4284
4285 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4286 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4287 BTC_TRACE(trace_buf);
4288 halbtc8703b1ant_ignore_wlan_act(btcoexist,
4289 FORCE_EXEC, FALSE);
4290 }
4291 }
4292
4293 }
4294
4295 halbtc8703b1ant_update_bt_link_info(btcoexist);
4296
4297 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
4298 }
4299
ex_halbtc8703b1ant_wl_fwdbginfo_notify(IN struct btc_coexist * btcoexist,IN u8 * tmp_buf,IN u8 length)4300 void ex_halbtc8703b1ant_wl_fwdbginfo_notify(IN struct btc_coexist *btcoexist,
4301 IN u8 *tmp_buf, IN u8 length)
4302 {
4303 u8 i = 0;
4304 static u8 tmp_buf_pre[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
4305
4306 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4307 "[BTCoex], WiFi Fw Dbg info = %d %d %d %d %d %d (len = %d)\n",
4308 tmp_buf[0], tmp_buf[1],
4309 tmp_buf[2], tmp_buf[3],
4310 tmp_buf[4], tmp_buf[5], length);
4311 BTC_TRACE(trace_buf);
4312
4313 if (tmp_buf[0] == 0x8) {
4314 for (i = 1; i <= 5; i++) {
4315 coex_sta->wl_fw_dbg_info[i] =
4316 (tmp_buf[i] >= tmp_buf_pre[i]) ?
4317 (tmp_buf[i] - tmp_buf_pre[i]) :
4318 (255 - tmp_buf_pre[i] + tmp_buf[i]);
4319
4320 tmp_buf_pre[i] = tmp_buf[i];
4321 }
4322 }
4323 }
4324
4325
ex_halbtc8703b1ant_rx_rate_change_notify(IN struct btc_coexist * btcoexist,IN BOOLEAN is_data_frame,IN u8 btc_rate_id)4326 void ex_halbtc8703b1ant_rx_rate_change_notify(IN struct btc_coexist *btcoexist,
4327 IN BOOLEAN is_data_frame, IN u8 btc_rate_id)
4328 {
4329 BOOLEAN wifi_connected = FALSE;
4330
4331 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4332 &wifi_connected);
4333
4334 if (is_data_frame) {
4335 coex_sta->wl_rx_rate = btc_rate_id;
4336
4337 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4338 "[BTCoex], rx_rate_change_notify data rate id = %d, RTS_Rate = %d\n",
4339 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate);
4340 BTC_TRACE(trace_buf);
4341 } else {
4342 coex_sta->wl_rts_rx_rate = btc_rate_id;
4343
4344 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4345 "[BTCoex], rts_rate_change_notify RTS rate id = %d, RTS_Rate = %d\n",
4346 coex_sta->wl_rts_rx_rate, coex_sta->wl_rts_rx_rate);
4347 BTC_TRACE(trace_buf);
4348 }
4349
4350 if ((wifi_connected) &&
4351 ((coex_dm->bt_status ==
4352 BT_8703B_1ANT_BT_STATUS_ACL_BUSY) ||
4353 (coex_dm->bt_status ==
4354 BT_8703B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
4355 (coex_dm->bt_status ==
4356 BT_8703B_1ANT_BT_STATUS_SCO_BUSY))) {
4357
4358 if ((coex_sta->wl_rx_rate == BTC_CCK_5_5) ||
4359 (coex_sta->wl_rx_rate == BTC_OFDM_6) ||
4360 (coex_sta->wl_rx_rate == BTC_MCS_0)) {
4361
4362 coex_sta->cck_lock_warn = TRUE;
4363
4364 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4365 "[BTCoex], cck lock warning...\n");
4366 BTC_TRACE(trace_buf);
4367 } else if ((coex_sta->wl_rx_rate == BTC_CCK_1) ||
4368 (coex_sta->wl_rx_rate == BTC_CCK_2) ||
4369 (coex_sta->wl_rts_rx_rate == BTC_CCK_1) ||
4370 (coex_sta->wl_rts_rx_rate == BTC_CCK_2)) {
4371
4372 coex_sta->cck_lock = TRUE;
4373 coex_sta->cck_lock_ever = TRUE;
4374
4375 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4376 "[BTCoex], cck locking...\n");
4377 BTC_TRACE(trace_buf);
4378 } else {
4379 coex_sta->cck_lock_warn = FALSE;
4380 coex_sta->cck_lock = FALSE;
4381
4382 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4383 "[BTCoex], cck unlock...\n");
4384 BTC_TRACE(trace_buf);
4385 }
4386 } else {
4387 if ((coex_dm->bt_status ==
4388 BT_8703B_1ANT_BT_STATUS_CONNECTED_IDLE) ||
4389 (coex_dm->bt_status ==
4390 BT_8703B_1ANT_BT_STATUS_NON_CONNECTED_IDLE)) {
4391 coex_sta->cck_lock_warn = FALSE;
4392 coex_sta->cck_lock = FALSE;
4393 }
4394 }
4395
4396 }
4397
4398
4399
ex_halbtc8703b1ant_rf_status_notify(IN struct btc_coexist * btcoexist,IN u8 type)4400 void ex_halbtc8703b1ant_rf_status_notify(IN struct btc_coexist *btcoexist,
4401 IN u8 type)
4402 {
4403 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
4404 BTC_TRACE(trace_buf);
4405
4406 if (BTC_RF_ON == type) {
4407 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4408 "[BTCoex], RF is turned ON!!\n");
4409 BTC_TRACE(trace_buf);
4410
4411 btcoexist->stop_coex_dm = FALSE;
4412 coex_sta->is_rf_state_off = FALSE;
4413 #if 0
4414 halbtc8703b1ant_post_state_to_bt(btcoexist,
4415 BT_8703B_1ANT_SCOREBOARD_ACTIVE, TRUE);
4416 halbtc8703b1ant_post_state_to_bt(btcoexist,
4417 BT_8703B_1ANT_SCOREBOARD_ONOFF, TRUE);
4418 #endif
4419 /* halbtc8703b1ant_init_hw_config(btcoexist, FALSE, FALSE); */
4420 } else if (BTC_RF_OFF == type) {
4421 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4422 "[BTCoex], RF is turned OFF!!\n");
4423 BTC_TRACE(trace_buf);
4424 halbtc8703b1ant_post_state_to_bt(btcoexist,
4425 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
4426 BT_8703B_1ANT_SCOREBOARD_ONOFF |
4427 BT_8703B_1ANT_SCOREBOARD_SCAN |
4428 BT_8703B_1ANT_SCOREBOARD_UNDERTEST,
4429 FALSE);
4430
4431 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4432 FORCE_EXEC,
4433 BT_8703B_1ANT_PHASE_WLAN_OFF);
4434
4435 halbtc8703b1ant_ps_tdma(btcoexist, FORCE_EXEC, FALSE, 0);
4436
4437 btcoexist->stop_coex_dm = TRUE;
4438 coex_sta->is_rf_state_off = TRUE;
4439 }
4440 }
4441
ex_halbtc8703b1ant_halt_notify(IN struct btc_coexist * btcoexist)4442 void ex_halbtc8703b1ant_halt_notify(IN struct btc_coexist *btcoexist)
4443 {
4444 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
4445 BTC_TRACE(trace_buf);
4446
4447 halbtc8703b1ant_post_state_to_bt(btcoexist,
4448 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
4449 BT_8703B_1ANT_SCOREBOARD_ONOFF |
4450 BT_8703B_1ANT_SCOREBOARD_SCAN |
4451 BT_8703B_1ANT_SCOREBOARD_UNDERTEST,
4452 FALSE);
4453
4454 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO, FORCE_EXEC,
4455 BT_8703B_1ANT_PHASE_WLAN_OFF);
4456
4457 ex_halbtc8703b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4458
4459 halbtc8703b1ant_enable_gnt_to_gpio(btcoexist, FALSE);
4460
4461 halbtc8703b1ant_ps_tdma(btcoexist, FORCE_EXEC, FALSE, 0);
4462
4463 btcoexist->stop_coex_dm = TRUE;
4464 }
4465
ex_halbtc8703b1ant_pnp_notify(IN struct btc_coexist * btcoexist,IN u8 pnp_state)4466 void ex_halbtc8703b1ant_pnp_notify(IN struct btc_coexist *btcoexist,
4467 IN u8 pnp_state)
4468 {
4469 static u8 pre_pnp_state;
4470
4471 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Pnp notify\n");
4472 BTC_TRACE(trace_buf);
4473
4474 if ((BTC_WIFI_PNP_SLEEP == pnp_state) ||
4475 (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state)) {
4476 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4477 "[BTCoex], Pnp notify to SLEEP\n");
4478 BTC_TRACE(trace_buf);
4479
4480 halbtc8703b1ant_post_state_to_bt(btcoexist,
4481 BT_8703B_1ANT_SCOREBOARD_ACTIVE |
4482 BT_8703B_1ANT_SCOREBOARD_ONOFF |
4483 BT_8703B_1ANT_SCOREBOARD_SCAN |
4484 BT_8703B_1ANT_SCOREBOARD_UNDERTEST,
4485 FALSE);
4486
4487 if (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state) {
4488
4489 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4490 FORCE_EXEC,
4491 BT_8703B_1ANT_PHASE_2G_RUNTIME);
4492 } else {
4493
4494 halbtc8703b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
4495 FORCE_EXEC,
4496 BT_8703B_1ANT_PHASE_WLAN_OFF);
4497 }
4498
4499 btcoexist->stop_coex_dm = TRUE;
4500 } else {
4501 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4502 "[BTCoex], Pnp notify to WAKE UP\n");
4503 BTC_TRACE(trace_buf);
4504
4505 if (pre_pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT ||
4506 pnp_state == BTC_WIFI_PNP_WOWLAN) {
4507 coex_sta->run_time_state = TRUE;
4508 btcoexist->stop_coex_dm = FALSE;
4509 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
4510 }
4511 }
4512 pre_pnp_state = pnp_state;
4513 }
4514
ex_halbtc8703b1ant_coex_dm_reset(IN struct btc_coexist * btcoexist)4515 void ex_halbtc8703b1ant_coex_dm_reset(IN struct btc_coexist *btcoexist)
4516 {
4517 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4518 "[BTCoex], *****************Coex DM Reset*****************\n");
4519 BTC_TRACE(trace_buf);
4520
4521 halbtc8703b1ant_init_hw_config(btcoexist, FALSE, FALSE);
4522 halbtc8703b1ant_init_coex_dm(btcoexist);
4523 }
4524
ex_halbtc8703b1ant_periodical(IN struct btc_coexist * btcoexist)4525 void ex_halbtc8703b1ant_periodical(IN struct btc_coexist *btcoexist)
4526 {
4527 u32 bt_patch_ver;
4528 boolean wifi_busy = FALSE;
4529 boolean bt_relink_finish = FALSE;
4530
4531 #if (BT_AUTO_REPORT_ONLY_8703B_1ANT == 0)
4532 halbtc8703b1ant_query_bt_info(btcoexist);
4533 #endif
4534
4535 halbtc8703b1ant_monitor_bt_ctr(btcoexist);
4536 halbtc8703b1ant_monitor_wifi_ctr(btcoexist);
4537
4538 halbtc8703b1ant_monitor_bt_enable_disable(btcoexist);
4539
4540 #if 0
4541 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
4542
4543 /* halbtc8703b1ant_read_score_board(btcoexist, &bt_scoreboard_val); */
4544
4545 if (wifi_busy) {
4546 halbtc8703b1ant_post_state_to_bt(btcoexist,
4547 BT_8703B_1ANT_SCOREBOARD_UNDERTEST, TRUE);
4548 /*
4549 halbtc8703b1ant_post_state_to_bt(btcoexist,
4550 BT_8703B_1ANT_SCOREBOARD_WLBUSY, TRUE);
4551
4552 if (bt_scoreboard_val & BIT(6))
4553 halbtc8703b1ant_query_bt_info(btcoexist); */
4554 } else {
4555 halbtc8703b1ant_post_state_to_bt(btcoexist,
4556 BT_8703B_1ANT_SCOREBOARD_UNDERTEST, FALSE);
4557 /*
4558 halbtc8703b1ant_post_state_to_bt(btcoexist,
4559 BT_8703B_1ANT_SCOREBOARD_WLBUSY,
4560 FALSE); */
4561 }
4562 #endif
4563
4564 if (coex_sta->bt_relink_downcount != 0) {
4565 coex_sta->bt_relink_downcount--;
4566
4567 if (coex_sta->bt_relink_downcount == 0) {
4568 coex_sta->is_setupLink = FALSE;
4569 bt_relink_finish = TRUE;
4570 }
4571 }
4572
4573 /* for 4-way, DHCP, EAPOL packet */
4574 if (coex_sta->specific_pkt_period_cnt > 0) {
4575
4576 coex_sta->specific_pkt_period_cnt--;
4577
4578 if ((coex_sta->specific_pkt_period_cnt == 0) &&
4579 (coex_sta->wifi_is_high_pri_task))
4580 coex_sta->wifi_is_high_pri_task = FALSE;
4581
4582 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4583 "[BTCoex], ***************** Hi-Pri Task = %s*****************\n",
4584 (coex_sta->wifi_is_high_pri_task ? "Yes" :
4585 "No"));
4586 BTC_TRACE(trace_buf);
4587
4588 }
4589
4590 if (halbtc8703b1ant_is_wifibt_status_changed(btcoexist) || (bt_relink_finish))
4591 halbtc8703b1ant_run_coexist_mechanism(btcoexist);
4592 }
4593
ex_halbtc8703b1ant_antenna_detection(IN struct btc_coexist * btcoexist,IN u32 cent_freq,IN u32 offset,IN u32 span,IN u32 seconds)4594 void ex_halbtc8703b1ant_antenna_detection(IN struct btc_coexist *btcoexist,
4595 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
4596 {
4597 /* No Antenna Detection required because 8730b is only 1-Ant */
4598 }
4599
ex_halbtc8703b1ant_antenna_isolation(IN struct btc_coexist * btcoexist,IN u32 cent_freq,IN u32 offset,IN u32 span,IN u32 seconds)4600 void ex_halbtc8703b1ant_antenna_isolation(IN struct btc_coexist *btcoexist,
4601 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
4602 {
4603
4604
4605 }
4606
ex_halbtc8703b1ant_psd_scan(IN struct btc_coexist * btcoexist,IN u32 cent_freq,IN u32 offset,IN u32 span,IN u32 seconds)4607 void ex_halbtc8703b1ant_psd_scan(IN struct btc_coexist *btcoexist,
4608 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
4609 {
4610
4611
4612 }
4613
ex_halbtc8703b1ant_display_ant_detection(IN struct btc_coexist * btcoexist)4614 void ex_halbtc8703b1ant_display_ant_detection(IN struct btc_coexist *btcoexist)
4615 {
4616
4617 }
4618
4619 #endif
4620
4621 #endif /* #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1) */
4622
4623