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