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